@amoree-code/ocean 0.0.0-stage → 1.2.0

package/node_modules/@ocean/brain/dist/memory/lesson-learning.js

@@ -0,0 +1,188 @@
+import { createHash } from "node:crypto";
+import { safeJsonParse } from "@ocean/core/shared/fs-utils.js";
+import { detectSessionSignals, hasUserCorrection, } from "@ocean/market/skills/signal-detection.js";
+import { addLesson, confirmLesson, contradictLesson, LessonRejectedError, readLesson, setLessonStatus, } from "./lessons.js";
+// What a closed session teaches the lessons store (T-230 P2). Scoring reads only signals a
+// session recorded itself — its exit, its evidence events — never the model's own claims.
+export const PROMOTION_HITS = 3;
+const MAX_NEW_LESSONS = 4;
+// verified = completed, exited 0, at least one proven evidence event, and none unproven.
+export function scoreSession(session, events) {
+    const exit = [...events].reverse().find((e) => e.type === "process_exit");
+    const exitCode = exit
+        ? Number(safeJsonParse(exit.data)?.exitCode ?? 1)
+        : session.status === "completed"
+            ? 0
+            : 1;
+    let provenCount = 0;
+    let unprovenCount = 0;
+    for (const event of events) {
+        if (event.type !== "evidence")
+            continue;
+        if (safeJsonParse(event.data)?.result === "proven")
+            provenCount += 1;
+        else
+            unprovenCount += 1;
+    }
+    return {
+        verified: session.status === "completed" &&
+            exitCode === 0 &&
+            provenCount > 0 &&
+            unprovenCount === 0,
+        provenCount,
+        unprovenCount,
+        exitCode,
+    };
+}
+// The replay eval: the lesson's hits must come from at least PROMOTION_HITS distinct
+// sessions, and each of those sessions must still score as verified when replayed from its
+// recorded events. A hit whose session has since vanished or no longer verifies does not count.
+export function replayEval(store) {
+    return async (lesson) => {
+        const sessionIds = [
+            ...new Set(lesson.evidence
+                .filter((ref) => ref.startsWith("session:"))
+                .map((ref) => ref.slice("session:".length))),
+        ];
+        const replayed = sessionIds.filter((id) => {
+            const session = store.get(id);
+            return session
+                ? scoreSession(session, store.listEvents(id)).verified
+                : false;
+        });
+        return replayed.length >= PROMOTION_HITS
+            ? { passed: true, reason: `${replayed.length} sessions replay verified` }
+            : {
+                passed: false,
+                reason: `${replayed.length} of ${PROMOTION_HITS} required sessions replay verified`,
+            };
+    };
+}
+// candidate → active, only with PROMOTION_HITS verified hits and a passing eval. Never
+// writes to charter/: that stays an owner decision.
+export async function promoteLesson(id, evaluate) {
+    const lesson = await readLesson(id);
+    if (!lesson)
+        return { promoted: false, reason: "not found" };
+    if (lesson.status !== "candidate")
+        return { promoted: false, reason: `already ${lesson.status}` };
+    if (lesson.hits < PROMOTION_HITS)
+        return {
+            promoted: false,
+            reason: `${lesson.hits} of ${PROMOTION_HITS} verified hits`,
+        };
+    const verdict = await evaluate(lesson);
+    if (!verdict.passed)
+        return { promoted: false, reason: verdict.reason };
+    await setLessonStatus(id, "active");
+    return { promoted: true, reason: verdict.reason };
+}
+function lessonIdFor(signal) {
+    const digest = createHash("sha256")
+        .update(`${signal.signalType}:${signal.summary.toLocaleLowerCase()}`)
+        .digest("hex");
+    return `lesson-${digest.slice(0, 16)}`;
+}
+function activatedLessonIds(events) {
+    const ids = events
+        .filter((event) => event.type === "skill_auto_activated")
+        .map((event) => safeJsonParse(event.data)?.id)
+        .filter((id) => typeof id === "string");
+    return [...new Set(ids)];
+}
+// Called once per session at closeout. A verified session confirms the lessons it used,
+// turns what it did into candidate lessons, and may promote a lesson that reached the bar.
+// An explicit user correction contradicts the lessons that were active when it happened.
+export async function learnFromSession(store, sessionId, now = new Date()) {
+    const session = store.get(sessionId);
+    if (!session)
+        throw new Error(`Session not found: ${sessionId}`);
+    const events = store.listEvents(sessionId);
+    const score = scoreSession(session, events);
+    const learning = {
+        score,
+        created: [],
+        confirmed: [],
+        contradicted: [],
+        promoted: [],
+        errors: [],
+    };
+    const evaluate = replayEval(store);
+    const corrected = hasUserCorrection(events);
+    const ref = `session:${sessionId}`;
+    // One lesson failing (an I/O or lock error) is recorded and skipped, never thrown: the
+    // changes already made to other lessons must still reach the audit event.
+    const guarded = async (id, work) => {
+        try {
+            await work();
+        }
+        catch (error) {
+            learning.errors.push(`${id}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    };
+    const reinforce = (id) => guarded(id, async () => {
+        await confirmLesson(id, { evidence: ref, now });
+        learning.confirmed.push(id);
+        if ((await promoteLesson(id, evaluate)).promoted)
+            learning.promoted.push(id);
+    });
+    for (const id of activatedLessonIds(events)) {
+        await guarded(id, async () => {
+            const lesson = await readLesson(id);
+            // A session that was already counted (closeout retried) is never counted twice.
+            if (!lesson ||
+                lesson.status === "retired" ||
+                lesson.evidence.includes(ref))
+                return;
+            if (corrected) {
+                await contradictLesson(id, {
+                    reason: "user corrected the session that used it",
+                    evidence: ref,
+                    now,
+                });
+                learning.contradicted.push(id);
+            }
+            else if (score.verified)
+                await reinforce(id);
+        });
+    }
+    if (!score.verified)
+        return learning;
+    for (const signal of detectSessionSignals(events).slice(0, MAX_NEW_LESSONS)) {
+        const id = lessonIdFor(signal);
+        await guarded(id, async () => {
+            const existing = await readLesson(id);
+            if (existing) {
+                // Seen again in another verified session: reinforcement, which counts as a hit.
+                if (existing.status !== "retired" && !existing.evidence.includes(ref))
+                    await reinforce(id);
+                return;
+            }
+            try {
+                // Evidence is the session only: event refs live in that session's own record, and
+                // a bounded list of them would push the session refs the replay eval needs out.
+                await addLesson({
+                    id,
+                    title: signal.summary.slice(0, 80),
+                    body: signal.summary,
+                    confidence: signal.confidence,
+                    evidence: [ref],
+                    sourceSessionId: sessionId,
+                }, now);
+                learning.created.push({
+                    id,
+                    signalType: signal.signalType,
+                    summary: signal.summary,
+                    confidence: signal.confidence,
+                });
+            }
+            catch (error) {
+                // Refused on its own terms (e.g. the summary looks like a secret).
+                if (!(error instanceof LessonRejectedError))
+                    throw error;
+            }
+        });
+    }
+    return learning;
+}
+//# sourceMappingURL=lesson-learning.js.map

package/node_modules/@ocean/brain/dist/memory/lessons.js

@@ -0,0 +1,321 @@
+import { createHash } from "node:crypto";
+import { mkdir, readdir, readFile, rename } from "node:fs/promises";
+import path from "node:path";
+import { atomicWrite, parseFrontmatter, withFileLock, } from "@ocean/core/shared/fs-utils.js";
+import { KNOWLEDGE_DIR, oceanPath, SYSTEM_DIR, } from "@ocean/core/shared/paths.js";
+export const LESSON_HALF_LIFE_DAYS = 30;
+const CONFIRM_STEP = 0.1;
+const CONTRADICT_FACTOR = 0.5;
+const RETIRE_BELOW = 0.1;
+const MAX_BODY_CHARS = 32_000;
+const MAX_EVIDENCE = 20;
+const DAY_MS = 86_400_000;
+const ID_PATTERN = /^[a-z0-9][a-z0-9-]{0,80}$/;
+const SECRET_PATTERN = /(api[_ -]?key|token|password|secret)\s*[:=]/i;
+export const lessonsDir = () => oceanPath(KNOWLEDGE_DIR, "lessons");
+const lessonFile = (id) => path.join(lessonsDir(), `${id}.md`);
+export const conflictsFile = () => path.join(lessonsDir(), "CONFLICTS.md");
+const clamp = (value) => Math.min(1, Math.max(0, value));
+// Confidence as of `now`: halves every LESSON_HALF_LIFE_DAYS since it was last written.
+export function effectiveConfidence(lesson, now = new Date()) {
+    const anchor = Date.parse(lesson.confidenceAt);
+    const ageDays = Number.isNaN(anchor)
+        ? 0
+        : Math.max(0, (now.getTime() - anchor) / DAY_MS);
+    return lesson.confidence * 0.5 ** (ageDays / LESSON_HALF_LIFE_DAYS);
+}
+function serialize(lesson) {
+    const summary = lesson.body.replace(/\s+/g, " ").trim().slice(0, 200);
+    const fields = [
+        ["id", lesson.id],
+        ["title", JSON.stringify(lesson.title)],
+        ["summary", JSON.stringify(summary)],
+        ["type", "experiential"],
+        ["status", lesson.status],
+        ["confidence", lesson.confidence.toFixed(4)],
+        ["confidence_at", lesson.confidenceAt],
+        ["hits", String(lesson.hits)],
+        ["evidence", JSON.stringify(lesson.evidence)],
+        ["scope", "global"],
+        ["created", lesson.created],
+        ["last_confirmed_at", lesson.lastConfirmedAt ?? ""],
+        ["source_session", lesson.sourceSessionId ?? ""],
+    ];
+    const head = fields
+        .filter(([, value]) => value !== "")
+        .map(([key, value]) => `${key}: ${value}`)
+        .join("\n");
+    return `---\n${head}\n---\n\n${lesson.body.trim()}\n`;
+}
+function parse(source) {
+    const fields = parseFrontmatter(source);
+    if (fields.type !== "experiential" || !fields.id)
+        return null;
+    const status = fields.status;
+    if (!["candidate", "active", "retired"].includes(status))
+        return null;
+    let evidence = [];
+    try {
+        const parsed = JSON.parse(fields.evidence ?? "[]");
+        if (Array.isArray(parsed))
+            evidence = parsed.map(String);
+    }
+    catch {
+        // A hand-edited, unparseable list is treated as no evidence rather than a lost lesson.
+    }
+    const normalized = source.replace(/\r\n/g, "\n");
+    const end = normalized.indexOf("\n---", 3);
+    return {
+        id: fields.id,
+        title: unquote(fields.title ?? fields.id),
+        body: (end < 0 ? "" : normalized.slice(end + 4)).trim(),
+        status,
+        confidence: clamp(Number(fields.confidence) || 0),
+        confidenceAt: fields.confidence_at || fields.created || "",
+        hits: Math.max(0, Math.trunc(Number(fields.hits) || 0)),
+        evidence,
+        created: fields.created ?? "",
+        lastConfirmedAt: fields.last_confirmed_at || null,
+        sourceSessionId: fields.source_session || null,
+    };
+}
+// parseFrontmatter strips only the outer quotes; JSON-encoded values keep inner escapes.
+function unquote(value) {
+    try {
+        return JSON.parse(`"${value}"`);
+    }
+    catch {
+        return value;
+    }
+}
+// A lesson the store refuses on its own terms (as opposed to an I/O failure): the migration
+// skips these and surfaces everything else.
+export class LessonRejectedError extends Error {
+}
+function assertClean(...texts) {
+    if (texts.some((text) => text !== undefined && SECRET_PATTERN.test(text)))
+        throw new LessonRejectedError("Invalid or sensitive lesson");
+}
+function assertValid(input) {
+    if (!ID_PATTERN.test(input.id) ||
+        !input.title.trim() ||
+        !input.body.trim() ||
+        input.body.length > MAX_BODY_CHARS)
+        throw new LessonRejectedError("Invalid or sensitive lesson");
+    assertClean(input.title, input.body, ...(input.evidence ?? []));
+}
+export async function readLesson(id) {
+    if (!ID_PATTERN.test(id))
+        return null;
+    try {
+        return parse(await readFile(lessonFile(id), "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+export async function listLessons(filter = {}) {
+    let names;
+    try {
+        names = await readdir(lessonsDir());
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+    const lessons = [];
+    for (const name of names.sort()) {
+        if (!name.endsWith(".md") || name === "CONFLICTS.md")
+            continue;
+        const lesson = await readLesson(name.slice(0, -3));
+        if (lesson && (!filter.status || lesson.status === filter.status))
+            lessons.push(lesson);
+    }
+    return lessons;
+}
+async function write(lesson) {
+    await mkdir(lessonsDir(), { recursive: true });
+    await atomicWrite(lessonFile(lesson.id), serialize(lesson), 0o600);
+}
+export async function addLesson(input, now = new Date()) {
+    assertValid(input);
+    const stamp = now.toISOString();
+    return withFileLock(lessonFile(input.id), async () => {
+        if (await readLesson(input.id))
+            throw new LessonRejectedError("Duplicate lesson");
+        const lesson = {
+            id: input.id,
+            title: input.title.trim(),
+            body: input.body.trim(),
+            status: input.status ?? "candidate",
+            confidence: clamp(input.confidence ?? 0.5),
+            confidenceAt: stamp,
+            hits: 0,
+            evidence: (input.evidence ?? []).slice(0, MAX_EVIDENCE),
+            created: stamp,
+            lastConfirmedAt: null,
+            sourceSessionId: input.sourceSessionId ?? null,
+        };
+        await write(lesson);
+        return lesson;
+    });
+}
+async function update(id, change) {
+    return withFileLock(lessonFile(id), async () => {
+        const lesson = await readLesson(id);
+        if (!lesson)
+            throw new Error(`Lesson not found: ${id}`);
+        await change(lesson);
+        await write(lesson);
+        return lesson;
+    });
+}
+// Confirmation on use: a verified use is a hit, restores the decayed confidence and a
+// little more, and restarts the decay clock.
+export async function confirmLesson(id, options = {}) {
+    const now = options.now ?? new Date();
+    assertClean(options.evidence);
+    return update(id, (lesson) => {
+        lesson.confidence = clamp(effectiveConfidence(lesson, now) + CONFIRM_STEP);
+        lesson.confidenceAt = now.toISOString();
+        lesson.lastConfirmedAt = now.toISOString();
+        lesson.hits += 1;
+        if (options.evidence && !lesson.evidence.includes(options.evidence))
+            lesson.evidence = [...lesson.evidence, options.evidence].slice(-MAX_EVIDENCE);
+    });
+}
+// The only way a lesson changes status outside contradiction. Callers own the rule that
+// justifies the move (see lesson-learning.ts for candidate → active).
+export async function setLessonStatus(id, status) {
+    return update(id, (lesson) => {
+        lesson.status = status;
+    });
+}
+// A contradicted fact loses confidence, the disagreement is written to CONFLICTS.md for
+// the owner, and a lesson that falls below RETIRE_BELOW is retired (kept, never deleted).
+export async function contradictLesson(id, options) {
+    const now = options.now ?? new Date();
+    assertClean(options.reason, options.evidence);
+    let entry = "";
+    const lesson = await update(id, (current) => {
+        const before = effectiveConfidence(current, now);
+        current.confidence = clamp(before * CONTRADICT_FACTOR);
+        current.confidenceAt = now.toISOString();
+        if (options.evidence && !current.evidence.includes(options.evidence))
+            current.evidence = [...current.evidence, options.evidence].slice(-MAX_EVIDENCE);
+        if (current.confidence < RETIRE_BELOW)
+            current.status = "retired";
+        const reason = options.reason.replace(/\s+/g, " ").trim().slice(0, 500);
+        entry =
+            `- ${now.toISOString()} \`${current.id}\` contradicted: ${reason}` +
+                ` (confidence ${before.toFixed(2)} → ${current.confidence.toFixed(2)}` +
+                `${current.status === "retired" ? ", retired" : ""}` +
+                `${options.evidence ? `; evidence ${options.evidence}` : ""})\n`;
+    });
+    // After the lesson is written, so the log never records a change that did not happen.
+    await appendConflict(entry);
+    return lesson;
+}
+async function appendConflict(line) {
+    await mkdir(lessonsDir(), { recursive: true });
+    await withFileLock(conflictsFile(), async () => {
+        const current = await readFile(conflictsFile(), "utf8").catch((error) => {
+            if (error.code === "ENOENT")
+                return "# Lesson conflicts\n\nContradicted lessons, newest last. Resolve by hand.\n\n";
+            throw error;
+        });
+        await atomicWrite(conflictsFile(), `${current}${line}`, 0o600);
+    });
+}
+async function readLegacy(file) {
+    try {
+        const parsed = JSON.parse(await readFile(file, "utf8"));
+        if (!Array.isArray(parsed))
+            throw new Error(`Legacy lesson store is not a JSON array: ${file}`);
+        return parsed;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+// `lesson-<id>`, lowercased to the id alphabet. A raw id that does not survive that unchanged
+// (or is too long) gets a hash suffix so two distinct legacy ids can never collide.
+function legacyLessonId(raw) {
+    const slug = `lesson-${raw}`.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+    if (slug === `lesson-${raw}` && slug.length <= 70)
+        return slug;
+    return `${slug.slice(0, 60)}-${createHash("sha256").update(raw).digest("hex").slice(0, 8)}`;
+}
+// Folds the two legacy lesson stores (skills/observations.json and skills/candidates.json)
+// into lessons, then renames each to `*.migrated` — never deleted. Idempotent: an existing
+// lesson id is skipped, and a renamed file is not read again. `system/observations/*.json`
+// is not migrated: those are raw `ocean observe` command logs, evidence a lesson can cite.
+export async function migrateLegacyLessons(now = new Date()) {
+    const skillsDir = oceanPath(SYSTEM_DIR, "skills");
+    const observationsFile = path.join(skillsDir, "observations.json");
+    const candidatesFile = path.join(skillsDir, "candidates.json");
+    const result = { migrated: 0, skipped: 0 };
+    const put = async (input, retired) => {
+        try {
+            await addLesson({ ...input, status: retired ? "retired" : input.status }, now);
+            result.migrated += 1;
+        }
+        catch (error) {
+            if (!(error instanceof LessonRejectedError))
+                throw error;
+            result.skipped += 1;
+        }
+    };
+    // Both files are read before anything is written: a corrupt one aborts a clean no-op.
+    const candidates = await readLegacy(candidatesFile);
+    const observations = await readLegacy(observationsFile);
+    const covered = new Set();
+    for (const item of candidates ?? []) {
+        if (!item.id || !item.instructions) {
+            result.skipped += 1;
+            continue;
+        }
+        covered.add(item.id);
+        const promoted = item.status === "promoted" && item.verification === "owner-reviewed";
+        await put({
+            id: legacyLessonId(item.id),
+            title: item.name ?? item.id,
+            body: item.instructions,
+            status: promoted ? "active" : "candidate",
+            confidence: promoted ? 0.8 : 0.5,
+            sourceSessionId: item.sourceSessionId,
+        }, item.status === "rejected");
+    }
+    for (const item of observations ?? []) {
+        if (!item.observationId || !item.summary) {
+            result.skipped += 1;
+            continue;
+        }
+        // An approved observation already became a candidate; that candidate is the lesson.
+        if (item.skillCandidateId && covered.has(item.skillCandidateId)) {
+            result.skipped += 1;
+            continue;
+        }
+        await put({
+            id: legacyLessonId(item.observationId),
+            title: item.summary.slice(0, 80),
+            body: item.summary,
+            confidence: item.confidence,
+            evidence: item.evidenceRefs,
+            sourceSessionId: item.sourceSessionId,
+        }, item.status === "discarded" || item.status === "rejected");
+    }
+    for (const [file, existed] of [
+        [candidatesFile, candidates],
+        [observationsFile, observations],
+    ])
+        if (existed)
+            await rename(file, `${file}.migrated`);
+    return result;
+}
+//# sourceMappingURL=lessons.js.map

package/node_modules/@ocean/brain/dist/memory/memory-audit.js

@@ -0,0 +1,100 @@
+import { createHash, randomBytes } from "node:crypto";
+import { appendFile, mkdir, open, readFile } from "node:fs/promises";
+import path from "node:path";
+import { withFileLock } from "@ocean/core/shared/fs-utils.js";
+import { oceanPath, SYSTEM_DIR } from "@ocean/core/shared/paths.js";
+import { auditFile } from "./memory-paths.js";
+export const DEFAULT_RETENTION_DAYS = 90;
+export function sha256(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
+// Sortable by time, unique enough for one workspace: 20261030161550-1a2b3c4d.
+export function newId(now = new Date()) {
+    const stamp = now
+        .toISOString()
+        .replace(/[-:TZ]/g, "")
+        .slice(0, 14);
+    return `${stamp}-${randomBytes(4).toString("hex")}`;
+}
+export function idTime(id) {
+    const match = /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})-/.exec(id);
+    if (!match)
+        return null;
+    const [, y, mo, d, h, mi, s] = match;
+    return new Date(`${y}-${mo}-${d}T${h}:${mi}:${s}Z`);
+}
+// A stored copy is written once and fsynced before the record it preserves is replaced.
+export async function writeDurable(file, content) {
+    await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+    const handle = await open(file, "wx", 0o600);
+    try {
+        await handle.writeFile(content, "utf8");
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function appendAudit(entry) {
+    const full = {
+        ...entry,
+        id: entry.id ?? newId(),
+        ts: new Date().toISOString(),
+    };
+    const file = auditFile();
+    await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+    await withFileLock(file, () => appendFile(file, `${JSON.stringify(full)}\n`, { mode: 0o600 }));
+    return full;
+}
+export async function readAudit() {
+    let text;
+    try {
+        text = await readFile(auditFile(), "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+    return text
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => JSON.parse(line));
+}
+// bridge/config/memory.json — optional; without it MCP writes are on, copies are kept 90 days and
+// pulled memory waits for review.
+export async function memorySettings() {
+    const file = oceanPath(SYSTEM_DIR, "config", "memory.json");
+    let input;
+    try {
+        input = JSON.parse(await readFile(file, "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return {
+                mcpWrites: true,
+                retentionDays: DEFAULT_RETENTION_DAYS,
+                pullAutoApprove: false,
+                proposeAutoApprove: false,
+            };
+        throw new Error(`Invalid memory settings in ${file}`);
+    }
+    const writes = input.mcpWrites ?? "on";
+    const days = input.retentionDays ?? DEFAULT_RETENTION_DAYS;
+    const pullApprove = input.pullAutoApprove ?? "off";
+    const proposeApprove = input.proposeAutoApprove ?? "off";
+    if ((writes !== "on" && writes !== "off") ||
+        (pullApprove !== "on" && pullApprove !== "off") ||
+        (proposeApprove !== "project" && proposeApprove !== "off") ||
+        typeof days !== "number" ||
+        !Number.isInteger(days) ||
+        days < 1)
+        throw new Error(`Invalid memory settings in ${file}`);
+    return {
+        mcpWrites: writes === "on",
+        retentionDays: days,
+        pullAutoApprove: pullApprove === "on",
+        proposeAutoApprove: proposeApprove === "project",
+    };
+}
+//# sourceMappingURL=memory-audit.js.map

package/node_modules/@ocean/brain/dist/memory/memory-digest.js

@@ -0,0 +1,49 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import { localDate } from "@ocean/core/shared/local-date.js";
+import { listProjectDirs, oceanPath, PERSONAL_DIR, } from "@ocean/core/shared/paths.js";
+import { readAudit } from "./memory-audit.js";
+import { listCandidates } from "./memory-review.js";
+// The memory reminder for /day-start (T-296 §3.10): at most five lines, each only when there is
+// something to act on. It reads; it never edits a record.
+const DAY = 86_400_000;
+async function openConflicts() {
+    const text = await readFile(oceanPath(PERSONAL_DIR, "CONFLICTS.md"), "utf8").catch(() => "");
+    // A conflict is a `## ` section; the template's `## <date> — <topic>` is not one.
+    return text.split("\n").filter((line) => /^## (?!<)/.test(line)).length;
+}
+async function projectsWithoutMemory() {
+    const missing = [];
+    for (const { id, dir } of listProjectDirs()) {
+        const isProject = await stat(oceanPath(dir, "project.json"))
+            .then(() => true)
+            .catch(() => false);
+        if (!isProject)
+            continue;
+        const records = await readdir(oceanPath(dir, "memory")).catch(() => []);
+        if (!records.some((name) => name.endsWith(".md") && name !== "MEMORY.md"))
+            missing.push(id);
+    }
+    return missing.sort();
+}
+export async function memoryDigest(options) {
+    const now = options.now ?? new Date();
+    const lines = [];
+    const conflicts = await openConflicts();
+    if (conflicts)
+        lines.push(`memory: ${conflicts} conflict(s) wait in 02-personal/CONFLICTS.md`);
+    const old = (await listCandidates()).filter((item) => now.getTime() - Date.parse(item.created) > 3 * DAY);
+    if (old.length)
+        lines.push(`memory: ${old.length} candidate(s) older than 3 days — ocean memory review`);
+    if (options.stale)
+        lines.push("memory: search index is stale — ocean memory reindex");
+    const bare = await projectsWithoutMemory();
+    if (bare.length)
+        lines.push(`memory: no records yet for ${bare.slice(0, 5).join(", ")}${bare.length > 5 ? ` (+${bare.length - 5})` : ""}`);
+    const yesterday = localDate(new Date(now.getTime() - DAY));
+    const writes = (await readAudit()).filter((entry) => (entry.action === "create" || entry.action === "update") &&
+        localDate(new Date(entry.ts)) === yesterday);
+    if (writes.length)
+        lines.push(`memory: ${writes.length} direct write(s) yesterday — ocean memory history`);
+    return lines;
+}
+//# sourceMappingURL=memory-digest.js.map