sessionmem 1.0.0

package/dist/core/api/sessionLifecycleService.js

@@ -0,0 +1,289 @@
+import { deterministicEmbed } from "../embed/deterministicEmbed.js";
+import { deleteMemoriesOlderThan as deleteMemoriesOlderThanDefault, upsertSessionSummaryMemory, } from "../storage/memoryRepo.js";
+import { configFilePath, DEFAULT_POLICY_CONFIG, readPolicyConfig, resolvePolicySettings, } from "../config/policyConfig.js";
+import { listSessionEventsBySession } from "../storage/sessionEventsRepo.js";
+import { insertSummarizationFailure } from "../storage/summarizationFailuresRepo.js";
+import { summarizeWithCloud } from "../summarize/cloudSummarizer.js";
+import { summarizeLocalSessionEvents, } from "../summarize/localSummarizer.js";
+import { resolveSummarizerMode } from "../summarize/strategySelector.js";
+const DEFAULT_EMBEDDING_DIMENSION = 32;
+const CLOUD_RETRY_CONFIG = {
+    retries: 2,
+};
+const CLOUD_ENABLED_MESSAGE = "Cloud summarization active: allowCloudSummarization=true and ANTHROPIC_API_KEY present";
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+function defaultFailureId() {
+    return `sumfail-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function toErrorJson(error) {
+    if (error instanceof Error) {
+        return JSON.stringify({
+            message: error.message,
+            name: error.name,
+        });
+    }
+    return JSON.stringify({ message: "Unknown error" });
+}
+async function retryCloud(fn) {
+    let attempt = 0;
+    let lastError;
+    while (attempt <= CLOUD_RETRY_CONFIG.retries) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            attempt += 1;
+            if (attempt > CLOUD_RETRY_CONFIG.retries) {
+                break;
+            }
+        }
+    }
+    throw lastError;
+}
+function storeSummaryMemory(db, embeddingDimension, input) {
+    const embedding = deterministicEmbed(input.summary, embeddingDimension);
+    upsertSessionSummaryMemory(db, {
+        id: input.memoryId,
+        project_id: input.projectId,
+        session_id: input.sessionId,
+        source_adapter: input.sourceAdapter,
+        kind: "summary",
+        content: input.summary,
+        normalized_content: embedding.normalizedText,
+        importance: 7,
+        embedding: JSON.stringify(embedding.vector),
+        embedding_dim: embedding.dimension,
+        embedding_version: embedding.embeddingVersion,
+        // Session summaries are locally authored.
+        author: input.author,
+        origin_project_id: null,
+    });
+}
+function buildMemoryId(request) {
+    return request.memoryId ?? `${request.sessionId}-summary`;
+}
+export function createSessionLifecycleService(deps) {
+    const summarizeLocal = deps.summarizeLocal ?? summarizeLocalSessionEvents;
+    const summarizeCloud = deps.summarizeCloud ?? summarizeWithCloud;
+    const embeddingDimension = deps.embeddingDimension ?? DEFAULT_EMBEDDING_DIMENSION;
+    const createFailureId = deps.createFailureId ?? defaultFailureId;
+    const author = deps.username ?? "";
+    const policyConfigPath = deps.policyConfigPath ?? configFilePath();
+    const now = deps.now ?? (() => new Date());
+    const deleteOldMemories = deps.deleteOldMemories ?? deleteMemoriesOlderThanDefault;
+    /**
+     * Resolve the effective retentionDays for a session-end prune. An explicit
+     * override wins (test seam); otherwise read the validated policy config, which
+     * itself falls back to the 90-day default on any failure.
+     */
+    function resolveRetentionDays() {
+        if (deps.retentionDaysOverride !== undefined) {
+            return deps.retentionDaysOverride;
+        }
+        try {
+            return readPolicyConfig(policyConfigPath).retentionDays;
+        }
+        catch {
+            return DEFAULT_POLICY_CONFIG.retentionDays;
+        }
+    }
+    /**
+     * Resolve the effective redactionEnabled flag for the session-end
+     * auto-summarize redaction step using precedence override (explicit
+     * request.config.redactionEnabled) > config.json > default, mirroring
+     * resolveRetentionDays. Falls back to the built-in default on any read
+     * failure.
+     */
+    function resolveRedactionEnabled(explicit) {
+        try {
+            return resolvePolicySettings({
+                override: explicit !== undefined ? { redactionEnabled: explicit } : undefined,
+                config: readPolicyConfig(policyConfigPath),
+            }).redactionEnabled;
+        }
+        catch {
+            return explicit ?? DEFAULT_POLICY_CONFIG.redactionEnabled;
+        }
+    }
+    /**
+     * Light, non-blocking retention prune executed once at session-end.
+     * Hard-deletes memories older than the effective retentionDays for this
+     * project. retentionDays<=0 disables pruning. Any failure is swallowed
+     * so it can never block or fail summarization.
+     */
+    function runLightPrune(projectId) {
+        try {
+            const retentionDays = resolveRetentionDays();
+            if (retentionDays <= 0) {
+                return;
+            }
+            const cutoffMs = now().getTime() - retentionDays * MS_PER_DAY;
+            // ISO-8601 UTC with millisecond precision matches the stored created_at
+            // format (strftime('%Y-%m-%dT%H:%M:%fZ')) for lexicographic comparison.
+            const cutoffIso = new Date(cutoffMs).toISOString();
+            deleteOldMemories(deps.db, projectId, cutoffIso);
+        }
+        catch {
+            // Light prune is best-effort: never block or fail summarization.
+        }
+    }
+    async function handleSessionEnd(request) {
+        const events = listSessionEventsBySession(deps.db, request.projectId, request.sessionId);
+        if (!request.config.autoSummarize) {
+            runLightPrune(request.projectId);
+            return {
+                ok: true,
+                status: "skipped_disabled",
+                usedMode: "local",
+                warningCodes: [],
+                warningMessages: [],
+            };
+        }
+        if (events.length < request.config.minimumEventThreshold) {
+            runLightPrune(request.projectId);
+            return {
+                ok: true,
+                status: "skipped_threshold",
+                usedMode: "local",
+                warningCodes: [],
+                warningMessages: [],
+            };
+        }
+        const mode = resolveSummarizerMode(request.config);
+        const memoryId = buildMemoryId(request);
+        const baseInput = {
+            events,
+            summaryTokenCap: request.config.summaryTokenCap,
+            redactionEnabled: resolveRedactionEnabled(request.config.redactionEnabled),
+            factMode: request.config.factMode,
+        };
+        if (mode === "cloud") {
+            try {
+                const cloudResult = await retryCloud(() => summarizeCloud({
+                    ...baseInput,
+                    anthropicApiKey: request.config.anthropicApiKey ?? "",
+                }));
+                storeSummaryMemory(deps.db, embeddingDimension, {
+                    memoryId,
+                    projectId: request.projectId,
+                    sessionId: request.sessionId,
+                    sourceAdapter: request.sourceAdapter,
+                    summary: cloudResult.summary,
+                    author,
+                });
+                runLightPrune(request.projectId);
+                return {
+                    ok: true,
+                    status: "stored",
+                    usedMode: "cloud",
+                    warningCodes: [
+                        "cloud_summarization_enabled",
+                        ...cloudResult.warningCodes,
+                    ],
+                    warningMessages: [CLOUD_ENABLED_MESSAGE],
+                    memoryId,
+                };
+            }
+            catch {
+                // fall back to local summarizer
+            }
+            try {
+                const fallbackResult = await summarizeLocal(baseInput);
+                storeSummaryMemory(deps.db, embeddingDimension, {
+                    memoryId,
+                    projectId: request.projectId,
+                    sessionId: request.sessionId,
+                    sourceAdapter: request.sourceAdapter,
+                    summary: fallbackResult.summary,
+                    author,
+                });
+                runLightPrune(request.projectId);
+                return {
+                    ok: true,
+                    status: "stored",
+                    usedMode: "local",
+                    warningCodes: [
+                        "cloud_summarization_enabled",
+                        "cloud_fallback_to_local",
+                        ...fallbackResult.warningCodes,
+                    ],
+                    warningMessages: [
+                        CLOUD_ENABLED_MESSAGE,
+                        "Cloud summarization failed; fallback to local summarizer succeeded.",
+                    ],
+                    memoryId,
+                };
+            }
+            catch (localError) {
+                const failureRecordId = createFailureId();
+                insertSummarizationFailure(deps.db, {
+                    id: failureRecordId,
+                    project_id: request.projectId,
+                    session_id: request.sessionId,
+                    source_adapter: request.sourceAdapter,
+                    reason: "cloud_and_local_failed",
+                    attempt_count: CLOUD_RETRY_CONFIG.retries + 2,
+                    last_error_json: toErrorJson(localError),
+                });
+                return {
+                    ok: true,
+                    status: "failed",
+                    usedMode: "local",
+                    warningCodes: [
+                        "cloud_summarization_enabled",
+                        "cloud_fallback_to_local_failed",
+                    ],
+                    warningMessages: [
+                        CLOUD_ENABLED_MESSAGE,
+                        "Cloud summarization failed; local fallback also failed.",
+                    ],
+                    failureRecordId,
+                };
+            }
+        }
+        try {
+            const localResult = await summarizeLocal(baseInput);
+            storeSummaryMemory(deps.db, embeddingDimension, {
+                memoryId,
+                projectId: request.projectId,
+                sessionId: request.sessionId,
+                sourceAdapter: request.sourceAdapter,
+                summary: localResult.summary,
+                author,
+            });
+            runLightPrune(request.projectId);
+            return {
+                ok: true,
+                status: "stored",
+                usedMode: "local",
+                warningCodes: localResult.warningCodes,
+                warningMessages: [],
+                memoryId,
+            };
+        }
+        catch (error) {
+            const failureRecordId = createFailureId();
+            insertSummarizationFailure(deps.db, {
+                id: failureRecordId,
+                project_id: request.projectId,
+                session_id: request.sessionId,
+                source_adapter: request.sourceAdapter,
+                reason: "local_failed",
+                attempt_count: 1,
+                last_error_json: toErrorJson(error),
+            });
+            return {
+                ok: true,
+                status: "failed",
+                usedMode: "local",
+                warningCodes: ["local_summarization_failed"],
+                warningMessages: [],
+                failureRecordId,
+            };
+        }
+    }
+    return {
+        handleSessionEnd,
+    };
+}

package/dist/core/config/policyConfig.js

@@ -0,0 +1,131 @@
+import { z } from "zod";
+import { homedir } from "os";
+import { join, dirname } from "path";
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+/**
+ * Built-in policy defaults. Used whenever the config file is missing, malformed,
+ * or fails validation, and as the lowest-precedence source in
+ * {@link resolvePolicySettings}.
+ *
+ * The default retention window is 90 days, and redaction defaults on.
+ */
+export const DEFAULT_POLICY_CONFIG = {
+    retentionDays: 90,
+    redactionEnabled: true,
+    team: { enabled: false },
+};
+/**
+ * Strict schema for the nested `team` section. `enabled` toggles team
+ * mode; `sharedPath` points at the shared filesystem store the `sync` command
+ * reads/writes. `.strict()` rejects unknown keys inside `team` so
+ * unrecognized fields can't slip through; `.default()` keeps backward compat
+ * for configs predating team mode (the section materializes as
+ * `{ enabled: false }`).
+ */
+const teamConfigShape = z
+    .object({
+    enabled: z.boolean().default(false),
+    sharedPath: z.string().optional(),
+})
+    .strict();
+/**
+ * Field definitions shared between the read and write schemas. `.default()`
+ * mirrors the pattern in src/core/api/contracts.ts so missing fields fall back to
+ * built-in defaults.
+ */
+const policyConfigShape = {
+    retentionDays: z.number().int().default(DEFAULT_POLICY_CONFIG.retentionDays),
+    redactionEnabled: z.boolean().default(DEFAULT_POLICY_CONFIG.redactionEnabled),
+    team: teamConfigShape.default({ enabled: false }),
+};
+/**
+ * Strict schema for `~/.sessionmem/config.json`. `.strict()` rejects unknown keys
+ * so caller-supplied writes cannot set unvalidated settings.
+ */
+export const policyConfigSchema = z.object(policyConfigShape).strict();
+/**
+ * Read schema. Unlike the write path, reading from disk STRIPS unknown keys
+ * rather than rejecting the whole file. This keeps known-good values when a
+ * config written by a newer binary carries fields this version doesn't know,
+ * while still discarding unvalidated keys. Type-invalid known fields still
+ * throw and trigger the safe-default fallback.
+ */
+const policyConfigReadSchema = z.object(policyConfigShape).strip();
+/**
+ * Canonical config-file location, mirroring the `~/.sessionmem` dir convention in
+ * src/cli/context.ts.
+ */
+export function configFilePath() {
+    return join(homedir(), ".sessionmem", "config.json");
+}
+/**
+ * Read and validate the policy config from disk.
+ *
+ * Defaults safely (like localOnlyPolicy.ts): any failure — missing file,
+ * unreadable file, malformed JSON, or schema-invalid contents — returns
+ * {@link DEFAULT_POLICY_CONFIG} without throwing. Stored values
+ * are merged over defaults via the schema's per-field `.default()`.
+ */
+export function readPolicyConfig(filePath) {
+    try {
+        const raw = readFileSync(filePath, "utf8");
+        const parsed = JSON.parse(raw);
+        return policyConfigReadSchema.parse(parsed);
+    }
+    catch {
+        return { ...DEFAULT_POLICY_CONFIG };
+    }
+}
+/**
+ * Persist a partial policy config, merged over the current on-disk values (or
+ * defaults when none exist). Creates parent directories as needed and writes
+ * pretty-printed JSON.
+ *
+ * The partial is validated against the strict schema, so unknown keys are
+ * rejected (throws) rather than silently written.
+ */
+export function writePolicyConfig(filePath, partial) {
+    // Validate the caller-supplied partial first so unknown keys are rejected
+    // before we touch the filesystem. `.partial()` keeps `.strict()` semantics.
+    const validatedPartial = policyConfigSchema.partial().parse(partial);
+    const current = readPolicyConfig(filePath);
+    const merged = policyConfigSchema.parse({ ...current, ...validatedPartial });
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, `${JSON.stringify(merged, null, 2)}\n`, "utf8");
+    return merged;
+}
+/**
+ * Resolve effective FLAT settings using precedence override > config.json >
+ * default. Each scalar setting is resolved independently.
+ *
+ * RESEARCH Pitfall 5: this loop assumes flat scalars. The nested `team` object
+ * is deliberately NOT routed through here — use {@link resolveTeamConfig} for it.
+ */
+export function resolvePolicySettings(input) {
+    const resolve = (key) => {
+        const fromOverride = input.override?.[key];
+        if (fromOverride !== undefined)
+            return fromOverride;
+        const fromConfig = input.config?.[key];
+        if (fromConfig !== undefined)
+            return fromConfig;
+        return DEFAULT_POLICY_CONFIG[key];
+    };
+    return {
+        retentionDays: resolve("retentionDays"),
+        redactionEnabled: resolve("redactionEnabled"),
+    };
+}
+/**
+ * Resolve the `team` config as a single object unit using precedence
+ * override > config.json > default (RESEARCH Pitfall 5). Unlike
+ * {@link resolvePolicySettings}, `team` is resolved whole — it is an object, not
+ * a flat scalar, so it must never be fed through the per-key scalar loop.
+ */
+export function resolveTeamConfig(input) {
+    if (input.override !== undefined)
+        return input.override;
+    if (input.config !== undefined)
+        return input.config;
+    return { ...DEFAULT_POLICY_CONFIG.team };
+}

package/dist/core/embed/deterministicEmbed.js

@@ -0,0 +1,31 @@
+import { createHash } from "node:crypto";
+import { EMBEDDING_VERSION } from "./embeddingVersion.js";
+import { normalizeEmbeddingText } from "./textNormalize.js";
+function nextHash(seed, blockIndex) {
+    return createHash("sha256").update(`${seed}:${blockIndex}`).digest();
+}
+export function deterministicEmbed(input, dimension) {
+    if (!Number.isInteger(dimension) || dimension <= 0) {
+        throw new Error("dimension must be a positive integer");
+    }
+    const normalizedText = normalizeEmbeddingText(input);
+    const vector = [];
+    let blockIndex = 0;
+    while (vector.length < dimension) {
+        const bytes = nextHash(normalizedText, blockIndex);
+        blockIndex += 1;
+        for (const byte of bytes) {
+            const value = (byte / 255) * 2 - 1;
+            vector.push(value);
+            if (vector.length === dimension) {
+                break;
+            }
+        }
+    }
+    return {
+        vector,
+        normalizedText,
+        dimension,
+        embeddingVersion: EMBEDDING_VERSION,
+    };
+}

package/dist/core/embed/embeddingVersion.js

@@ -0,0 +1 @@
+export const EMBEDDING_VERSION = "v1-hash-local";

package/dist/core/embed/reembedPolicy.js

@@ -0,0 +1,9 @@
+export function shouldReembed(previous, nextNormalizedText, currentVersion) {
+    if (previous.normalizedText !== nextNormalizedText) {
+        return true;
+    }
+    if (previous.embeddingVersion !== currentVersion) {
+        return true;
+    }
+    return false;
+}

package/dist/core/embed/textNormalize.js

@@ -0,0 +1,12 @@
+const INTERNAL_WHITESPACE = /\s+/g;
+/**
+ * Normalize text before deterministic embedding generation.
+ * Order is fixed by plan contract: trim -> collapse whitespace -> NFKC -> lowercase.
+ */
+export function normalizeEmbeddingText(text) {
+    return text
+        .trim()
+        .replace(INTERNAL_WHITESPACE, " ")
+        .normalize("NFKC")
+        .toLowerCase();
+}

package/dist/core/injection/formatStartupInjection.js

@@ -0,0 +1,97 @@
+import { countTokens, trimLowestPriorityContent } from "./tokenBudget.js";
+const DEFAULT_TOKEN_CAP = 450;
+const HEADER = "Relevant prior context";
+const KIND_ORDER = ["warning", "decision", "fact", "summary", "preference"];
+const KIND_RANK = new Map(KIND_ORDER.map((kind, index) => [kind, index]));
+function kindRank(kind) {
+    return KIND_RANK.get(kind) ?? KIND_ORDER.length;
+}
+function isCriticalWarning(memory) {
+    return memory.kind === "warning" && memory.importance >= 9;
+}
+function sortMemories(memories) {
+    return [...memories].sort((left, right) => {
+        const leftRank = kindRank(left.kind);
+        const rightRank = kindRank(right.kind);
+        if (leftRank !== rightRank) {
+            return leftRank - rightRank;
+        }
+        if (leftRank === KIND_ORDER.length && left.kind !== right.kind) {
+            return left.kind.localeCompare(right.kind);
+        }
+        if (right.score.total !== left.score.total) {
+            return right.score.total - left.score.total;
+        }
+        if (right.updated_at !== left.updated_at) {
+            return right.updated_at.localeCompare(left.updated_at);
+        }
+        return left.id.localeCompare(right.id);
+    });
+}
+function formatScore(value) {
+    return value.toFixed(3);
+}
+function authorPrefix(memory, localUsername) {
+    if (memory.author &&
+        localUsername &&
+        memory.author !== localUsername) {
+        return `${memory.author}: `;
+    }
+    return "";
+}
+function formatLine(entry, localUsername) {
+    const { memory } = entry;
+    const score = memory.score;
+    const prefix = authorPrefix(memory, localUsername);
+    return [
+        `- [${memory.kind}] ${prefix}${entry.content}`,
+        `(score total=${formatScore(score.total)}, semantic=${formatScore(score.raw.semantic)}, recency=${formatScore(score.raw.recency)}, importance=${formatScore(score.raw.importance)}; source=${memory.source_adapter}; date=${memory.updated_at})`,
+    ].join(" ");
+}
+function render(entries, localUsername) {
+    if (entries.length === 0) {
+        return HEADER;
+    }
+    return [
+        HEADER,
+        ...entries.map((entry) => formatLine(entry, localUsername)),
+    ].join("\n");
+}
+function lowestDroppableIndex(entries) {
+    let index = -1;
+    for (let i = 0; i < entries.length; i += 1) {
+        if (entries[i].preserve) {
+            continue;
+        }
+        if (index === -1 || entries[i].priority < entries[index].priority) {
+            index = i;
+        }
+    }
+    return index;
+}
+export function formatStartupInjection(rankedMemories, options = {}) {
+    const tokenCap = options.tokenCap ?? DEFAULT_TOKEN_CAP;
+    const localUsername = options.localUsername;
+    let included = sortMemories(rankedMemories).map((memory) => ({
+        memory,
+        content: memory.content,
+        priority: KIND_ORDER.length - kindRank(memory.kind),
+        preserve: isCriticalWarning(memory),
+    }));
+    let output = render(included, localUsername);
+    while (included.length > 0 && countTokens(output) > tokenCap) {
+        const trimmed = trimLowestPriorityContent(included);
+        if (trimmed.some((entry, index) => entry.content !== included[index].content)) {
+            included = trimmed;
+            output = render(included, localUsername);
+            continue;
+        }
+        const dropIndex = lowestDroppableIndex(included);
+        if (dropIndex === -1) {
+            break;
+        }
+        included = included.filter((_, index) => index !== dropIndex);
+        output = render(included, localUsername);
+    }
+    return output;
+}

package/dist/core/injection/tokenBudget.js

@@ -0,0 +1,38 @@
+import { getEncoding } from "js-tiktoken";
+const encoding = getEncoding("o200k_base");
+const DEFAULT_MIN_CONTENT_TOKENS = 12;
+const DEFAULT_TRIM_RATIO = 0.75;
+export function countTokens(text) {
+    return encoding.encode(text).length;
+}
+export function trimLowestPriorityContent(included, options = {}) {
+    const minContentTokens = options.minContentTokens ?? DEFAULT_MIN_CONTENT_TOKENS;
+    const trimRatio = options.trimRatio ?? DEFAULT_TRIM_RATIO;
+    const ordered = [...included].sort((left, right) => {
+        if (left.preserve !== right.preserve) {
+            return left.preserve ? 1 : -1;
+        }
+        if (left.priority !== right.priority) {
+            return left.priority - right.priority;
+        }
+        return countTokens(right.content) - countTokens(left.content);
+    });
+    const target = ordered.find((entry) => {
+        return !entry.preserve && countTokens(entry.content) > minContentTokens;
+    });
+    if (!target) {
+        return included;
+    }
+    return included.map((entry) => {
+        if (entry !== target) {
+            return entry;
+        }
+        const tokens = encoding.encode(entry.content);
+        const keepCount = Math.max(minContentTokens, Math.floor(tokens.length * trimRatio));
+        const trimmed = encoding.decode(tokens.slice(0, keepCount)).trimEnd();
+        return {
+            ...entry,
+            content: `${trimmed}...`,
+        };
+    });
+}

package/dist/core/retrieve/decay.js

@@ -0,0 +1,15 @@
+const DEFAULT_DECAY_THRESHOLD_DAYS = 7;
+const DAY_IN_MS = 24 * 60 * 60 * 1000;
+export function decayOldBoosts(memories, now = new Date(), thresholdDays = DEFAULT_DECAY_THRESHOLD_DAYS) {
+    return memories.map((memory) => {
+        const updatedAt = new Date(memory.updated_at);
+        const ageDays = Math.max(0, (now.getTime() - updatedAt.getTime()) / DAY_IN_MS);
+        const shouldDecay = Number.isFinite(ageDays) && ageDays > thresholdDays;
+        return {
+            ...memory,
+            decayedImportance: shouldDecay
+                ? Math.max(1, memory.importance - 1)
+                : memory.importance,
+        };
+    });
+}

package/dist/core/retrieve/importance.js

@@ -0,0 +1,6 @@
+export function normalizeImportance(score1to10) {
+    if (!Number.isFinite(score1to10) || score1to10 < 1 || score1to10 > 10) {
+        throw new Error("importance must be between 1 and 10");
+    }
+    return (score1to10 - 1) / 9;
+}

package/dist/core/retrieve/recencyBands.js

@@ -0,0 +1,18 @@
+const DAY_IN_MS = 24 * 60 * 60 * 1000;
+function toDate(value) {
+    return value instanceof Date ? value : new Date(value);
+}
+export function getRecencyBandScore(updatedAt, now = new Date()) {
+    const updatedDate = toDate(updatedAt);
+    const ageDays = Math.max(0, (now.getTime() - updatedDate.getTime()) / DAY_IN_MS);
+    if (ageDays <= 1) {
+        return 1.0;
+    }
+    if (ageDays <= 7) {
+        return 0.75;
+    }
+    if (ageDays <= 30) {
+        return 0.5;
+    }
+    return 0.25;
+}