@chenpengfei/daily-brief 0.1.0

package/dist/src/config/credential-store.js

@@ -0,0 +1,169 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { resolveDailyBriefPaths } from "./paths.js";
+export function readCredentialStore(path = resolveDailyBriefPaths().authPath) {
+    if (!existsSync(path)) {
+        return { credentials: {} };
+    }
+    const payload = JSON.parse(readFileSync(path, "utf8"));
+    if (!isRecord(payload)) {
+        throw new Error("auth.json must be a JSON object");
+    }
+    return parseCredentialStore(payload);
+}
+export function writeCredentialStore(store, path = resolveDailyBriefPaths().authPath) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(parseCredentialStore(store), null, 2)}\n`, {
+        mode: 0o600
+    });
+}
+export function putCredential(ref, credential, path = resolveDailyBriefPaths().authPath) {
+    assertStoredCredentialRef(ref);
+    const now = new Date().toISOString();
+    const store = readCredentialStore(path);
+    const previous = store.credentials[ref];
+    store.credentials[ref] = {
+        ...credential,
+        createdAt: previous?.createdAt ?? credential.createdAt ?? now,
+        updatedAt: now
+    };
+    writeCredentialStore(store, path);
+    return store;
+}
+export function removeCredential(ref, path = resolveDailyBriefPaths().authPath) {
+    assertStoredCredentialRef(ref);
+    const store = readCredentialStore(path);
+    delete store.credentials[ref];
+    writeCredentialStore(store, path);
+    return store;
+}
+export function getCredential(ref, path = resolveDailyBriefPaths().authPath) {
+    if (isEnvCredentialRef(ref)) {
+        return undefined;
+    }
+    assertStoredCredentialRef(ref);
+    return readCredentialStore(path).credentials[ref];
+}
+export function redactCredentialStore(store) {
+    return Object.fromEntries(Object.entries(store.credentials).map(([ref, credential]) => [
+        ref,
+        {
+            type: credential.type,
+            provider: credential.provider,
+            secret: "<redacted>"
+        }
+    ]));
+}
+export function isEnvCredentialRef(ref) {
+    return ref.startsWith("env:") && ref.slice("env:".length).trim().length > 0;
+}
+export function envNameFromCredentialRef(ref) {
+    if (!isEnvCredentialRef(ref)) {
+        throw new Error(`Credential reference is not an env ref: ${ref}`);
+    }
+    return ref.slice("env:".length).trim();
+}
+export function assertStoredCredentialRef(ref) {
+    if (isEnvCredentialRef(ref)) {
+        throw new Error(`Credential reference ${ref} is environment-backed and cannot be stored in auth.json`);
+    }
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(ref)) {
+        throw new Error(`Invalid credentialRef: ${ref}`);
+    }
+}
+function parseCredentialStore(value) {
+    const credentials = value.credentials;
+    if (credentials === undefined) {
+        return { credentials: {} };
+    }
+    if (!isRecord(credentials)) {
+        throw new Error("auth.json credentials must be a mapping");
+    }
+    return {
+        credentials: Object.fromEntries(Object.entries(credentials).map(([ref, credential]) => {
+            assertStoredCredentialRef(ref);
+            if (!isRecord(credential)) {
+                throw new Error(`Credential ${ref} must be a mapping`);
+            }
+            return [ref, parseCredentialRecord(ref, credential)];
+        }))
+    };
+}
+function parseCredentialRecord(ref, value) {
+    if (value.type === "api-key") {
+        const provider = readProvider(value.provider, ref);
+        const apiKey = readString(value.apiKey, `Credential ${ref} apiKey`);
+        return {
+            type: "api-key",
+            provider,
+            apiKey,
+            ...readTimestamps(value)
+        };
+    }
+    if (value.type === "oauth") {
+        const provider = readProvider(value.provider, ref);
+        if (provider !== "openai-codex") {
+            throw new Error(`Credential ${ref} OAuth provider must be openai-codex`);
+        }
+        if (!isRecord(value.credentials)) {
+            throw new Error(`Credential ${ref} credentials must be a mapping`);
+        }
+        const credentials = value.credentials;
+        const refresh = readString(credentials.refresh, `Credential ${ref} refresh`);
+        const access = readString(credentials.access, `Credential ${ref} access`);
+        const expires = typeof credentials.expires === "number" ? credentials.expires : undefined;
+        if (!expires) {
+            throw new Error(`Credential ${ref} expires must be a number`);
+        }
+        return {
+            type: "oauth",
+            provider,
+            credentials: {
+                ...credentials,
+                refresh,
+                access,
+                expires
+            },
+            ...readTimestamps(value)
+        };
+    }
+    if (value.type === "webhook") {
+        const provider = readString(value.provider, `Credential ${ref} provider`);
+        if (provider !== "discord") {
+            throw new Error(`Credential ${ref} webhook provider must be discord`);
+        }
+        return {
+            type: "webhook",
+            provider,
+            webhookUrl: readString(value.webhookUrl, `Credential ${ref} webhookUrl`),
+            ...readTimestamps(value)
+        };
+    }
+    throw new Error(`Credential ${ref} type must be api-key, oauth, or webhook`);
+}
+function readProvider(value, ref) {
+    const provider = readString(value, `Credential ${ref} provider`).toLowerCase();
+    if (provider === "faux" ||
+        provider === "openai" ||
+        provider === "openai-codex" ||
+        provider === "deepseek" ||
+        provider === "openai-compatible") {
+        return provider;
+    }
+    throw new Error(`Credential ${ref} has unsupported provider: ${provider}`);
+}
+function readTimestamps(value) {
+    return {
+        ...(typeof value.createdAt === "string" ? { createdAt: value.createdAt } : {}),
+        ...(typeof value.updatedAt === "string" ? { updatedAt: value.updatedAt } : {})
+    };
+}
+function readString(value, field) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`${field} is required`);
+    }
+    return value.trim();
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/src/config/date-key.js

@@ -0,0 +1,25 @@
+export function formatDateKey(date, timeZone = "UTC") {
+    const parts = new Intl.DateTimeFormat("en-US", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit"
+    }).formatToParts(date);
+    const year = readPart(parts, "year");
+    const month = readPart(parts, "month");
+    const day = readPart(parts, "day");
+    return `${year}-${month}-${day}`;
+}
+export function dateFromDateKey(dateKey) {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(dateKey)) {
+        throw new Error(`Invalid date key: ${dateKey}`);
+    }
+    return new Date(`${dateKey}T00:00:00.000Z`);
+}
+function readPart(parts, type) {
+    const part = parts.find((entry) => entry.type === type)?.value;
+    if (!part) {
+        throw new Error(`Unable to format date part: ${type}`);
+    }
+    return part;
+}

package/dist/src/config/index.js

@@ -0,0 +1,5 @@
+export * from "./credential-store.js";
+export * from "./date-key.js";
+export * from "./model-config.js";
+export * from "./paths.js";
+export * from "./source-registry.js";

package/dist/src/config/model-config.js

@@ -0,0 +1,123 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { parse, stringify } from "yaml";
+import { resolveDailyBriefPaths } from "./paths.js";
+export function readDailyBriefConfig(path = resolveDailyBriefPaths().configPath) {
+    if (!existsSync(path)) {
+        return {};
+    }
+    const contents = readFileSync(path, "utf8");
+    const parsed = parse(contents);
+    if (!isRecord(parsed)) {
+        throw new Error("Daily Brief config must be a mapping");
+    }
+    return parseDailyBriefConfig(parsed);
+}
+export function readModelConfig(path = resolveDailyBriefPaths().configPath) {
+    return readDailyBriefConfig(path).model;
+}
+export function readConfiguredTimezone(path = resolveDailyBriefPaths().configPath) {
+    const timezone = readDailyBriefConfig(path).timezone;
+    return typeof timezone === "string" && timezone.trim().length > 0 ? timezone.trim() : undefined;
+}
+export function writeModelConfig(config, path = resolveDailyBriefPaths().configPath) {
+    const current = readDailyBriefConfig(path);
+    const next = {
+        ...current,
+        model: parseModelConfig(config)
+    };
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, stringify(next), "utf8");
+}
+export function parseDailyBriefConfig(value) {
+    const config = { ...value };
+    if (value.model !== undefined) {
+        if (!isRecord(value.model)) {
+            throw new Error("config.model must be a mapping");
+        }
+        config.model = parseModelConfig(value.model);
+    }
+    if (value.delivery !== undefined) {
+        if (!isRecord(value.delivery)) {
+            throw new Error("config.delivery must be a mapping");
+        }
+        config.delivery = parseDeliveryConfig(value.delivery);
+    }
+    return config;
+}
+export function readDeliveryConfig(path = resolveDailyBriefPaths().configPath) {
+    return readDailyBriefConfig(path).delivery;
+}
+export function writeDeliveryConfig(config, path = resolveDailyBriefPaths().configPath) {
+    const current = readDailyBriefConfig(path);
+    const next = { ...current, delivery: parseDeliveryConfig(config) };
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, stringify(next), "utf8");
+}
+function parseDeliveryConfig(value) {
+    if (typeof value.enabled !== "boolean") {
+        throw new Error("config.delivery.enabled must be a boolean");
+    }
+    const webhookRef = readOptionalString(value.webhookRef, "config.delivery.webhookRef");
+    return {
+        enabled: value.enabled,
+        ...(webhookRef ? { webhookRef } : {})
+    };
+}
+export function parseModelConfig(value) {
+    const provider = readProvider(value.provider);
+    const model = readRequiredString(value.model, "config.model.model");
+    const credentialRef = readOptionalString(value.credentialRef, "config.model.credentialRef");
+    const baseUrl = readOptionalString(value.baseUrl, "config.model.baseUrl");
+    if ("apiKey" in value || "secret" in value || "accessToken" in value || "refreshToken" in value) {
+        throw new Error("config.model must not contain secrets; use auth.json via credentialRef");
+    }
+    if (provider === "openai-compatible" && !baseUrl) {
+        throw new Error("config.model.baseUrl is required when provider is openai-compatible");
+    }
+    return {
+        provider,
+        model,
+        ...(credentialRef ? { credentialRef } : {}),
+        ...(baseUrl ? { baseUrl } : {})
+    };
+}
+export function defaultModelConfig() {
+    return {
+        provider: "openai-codex",
+        model: "gpt-5.5",
+        credentialRef: "openai-codex.default"
+    };
+}
+function readProvider(value) {
+    const provider = readRequiredString(value, "config.model.provider").toLowerCase();
+    if (provider === "codex" || provider === "hermes") {
+        return "openai-codex";
+    }
+    if (provider === "faux") {
+        throw new Error("config.model.provider must not be faux; faux is only available through test-only runtime injection");
+    }
+    if (provider === "openai-codex" || provider === "openai" || provider === "deepseek" || provider === "openai-compatible") {
+        return provider;
+    }
+    throw new Error(`Unsupported model provider: ${provider}`);
+}
+function readRequiredString(value, field) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`${field} is required`);
+    }
+    return value.trim();
+}
+function readOptionalString(value, field) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value !== "string") {
+        throw new Error(`${field} must be a string`);
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/src/config/paths.js

@@ -0,0 +1,20 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+export function resolveDailyBriefPaths(env = process.env) {
+    const home = nonEmpty(env.DAILY_BRIEF_HOME) ?? join(homedir(), ".daily-brief");
+    const dataHome = nonEmpty(env.DAILY_BRIEF_DATA_HOME) ?? join(home, "data");
+    return {
+        home,
+        dataHome,
+        configPath: join(home, "config.yaml"),
+        sourceRegistryPath: join(home, "sources.yaml"),
+        authPath: join(home, "auth.json"),
+        sourceItemRoot: join(dataHome, "source-items"),
+        agentRunRoot: join(dataHome, "agent-runs"),
+        briefArchiveRoot: join(dataHome, "briefs")
+    };
+}
+function nonEmpty(value) {
+    const trimmed = value?.trim();
+    return trimmed && trimmed.length > 0 ? trimmed : undefined;
+}

package/dist/src/config/source-registry.js

@@ -0,0 +1,48 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { isMap, isSeq, parse, parseDocument } from "yaml";
+import { parseSourceRegistry } from "../domain/index.js";
+import { resolveDailyBriefPaths } from "./paths.js";
+export async function loadSourceRegistry(path = resolveDailyBriefPaths().sourceRegistryPath) {
+    const contents = await readFile(path, "utf8");
+    return parseSourceRegistry(parse(contents));
+}
+export async function validateSourceRegistry(path = resolveDailyBriefPaths().sourceRegistryPath) {
+    return loadSourceRegistry(path);
+}
+export async function setSourceEnabled(id, enabled, path = resolveDailyBriefPaths().sourceRegistryPath) {
+    const contents = await readFile(path, "utf8");
+    const document = parseDocument(contents);
+    const sources = document.get("sources", true);
+    if (!isSeq(sources)) {
+        throw new Error("Source Registry must contain a sources list");
+    }
+    let found = false;
+    for (const source of sources.items) {
+        if (!isMap(source)) {
+            continue;
+        }
+        if (source.get("id") === id) {
+            source.set("enabled", enabled);
+            found = true;
+            break;
+        }
+    }
+    if (!found) {
+        throw new Error(`Source not found: ${id}`);
+    }
+    const nextContents = String(document);
+    const registry = parseSourceRegistry(parse(nextContents));
+    await writeFile(path, nextContents, "utf8");
+    return registry;
+}
+export function formatSourceRegistry(registry) {
+    if (registry.sources.length === 0) {
+        return "No Sources configured.";
+    }
+    return registry.sources
+        .map((source) => {
+        const state = source.enabled ? "enabled" : "disabled";
+        return `${state.padEnd(8)} ${source.id} ${source.platform}/${source.adapter} ${source.target}`;
+    })
+        .join("\n");
+}

package/dist/src/discord/delivery.js

@@ -0,0 +1,84 @@
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { getCredential, readDeliveryConfig, resolveDailyBriefPaths } from "../config/index.js";
+import { createCoreWorkflowFailureNotification } from "../workflow/index.js";
+export async function renderDiscordNotification(input) {
+    const template = await readDiscordTemplate(input.templatePath);
+    const date = input.brief.date.toISOString().slice(0, 10);
+    const summaryBullets = buildSummaryBullets(input.brief);
+    return template
+        .replaceAll("{{date}}", date)
+        .replaceAll("{{summary_bullets}}", summaryBullets)
+        .replaceAll("{{brief_path}}", input.briefPath)
+        .trim();
+}
+export async function deliverDiscordNotification(input, options = {}) {
+    const content = await renderDiscordNotification(input);
+    return sendDiscordContent(content, options);
+}
+export async function deliverCoreFailureNotification(failure, options = {}) {
+    return sendDiscordContent(createCoreWorkflowFailureNotification(failure), options);
+}
+async function sendDiscordContent(content, options) {
+    const webhookUrl = options.webhookUrl ?? resolveConfiguredWebhookUrl(options.env ?? process.env);
+    if (!webhookUrl) {
+        return { status: "skipped", reason: "DISCORD_WEBHOOK_URL is not configured" };
+    }
+    try {
+        const fetchImpl = options.fetchImpl ?? fetch;
+        const response = await fetchImpl(webhookUrl, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json"
+            },
+            body: JSON.stringify({ content })
+        });
+        if (!response.ok) {
+            return { status: "failed", reason: `Discord webhook returned ${response.status}` };
+        }
+        return { status: "sent" };
+    }
+    catch (error) {
+        return { status: "failed", reason: error instanceof Error ? error.message : String(error) };
+    }
+}
+async function readDiscordTemplate(templatePath) {
+    if (templatePath) {
+        return readFile(templatePath, "utf8");
+    }
+    const candidates = [
+        fileURLToPath(new URL("../../templates/discord-notification.md", import.meta.url)),
+        fileURLToPath(new URL("../../../templates/discord-notification.md", import.meta.url))
+    ];
+    let lastError;
+    for (const candidate of candidates) {
+        try {
+            return await readFile(candidate, "utf8");
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error("Discord notification template not found");
+}
+export function resolveConfiguredWebhookUrl(env = process.env) {
+    if (env.DISCORD_WEBHOOK_URL) {
+        return env.DISCORD_WEBHOOK_URL;
+    }
+    const paths = resolveDailyBriefPaths(env);
+    const config = readDeliveryConfig(paths.configPath);
+    if (!config?.enabled || !config.webhookRef) {
+        return undefined;
+    }
+    const credential = getCredential(config.webhookRef, paths.authPath);
+    return credential?.type === "webhook" && credential.provider === "discord" ? credential.webhookUrl : undefined;
+}
+function buildSummaryBullets(brief) {
+    if (brief.signals.length === 0) {
+        return "- low-signal day：暂无可引用的 Top Signals";
+    }
+    return brief.signals
+        .slice(0, 3)
+        .map((signal) => `- [${signal.type}] ${signal.title}`)
+        .join("\n");
+}

package/dist/src/discord/index.js

@@ -0,0 +1 @@
+export * from "./delivery.js";

package/dist/src/domain/index.js

@@ -0,0 +1,2 @@
+export * from "./source.js";
+export * from "./source-item.js";

package/dist/src/domain/source-item.js

@@ -0,0 +1,21 @@
+import { createHash } from "node:crypto";
+export function createSourceItem(input) {
+    return {
+        ...input,
+        contentHash: hashSourceItemContent(input)
+    };
+}
+export function hashSourceItemContent(input) {
+    return createHash("sha256")
+        .update(JSON.stringify({
+        sourceId: input.sourceId,
+        platform: input.platform,
+        url: input.url,
+        title: input.title,
+        author: input.author,
+        publishedAt: input.publishedAt,
+        analyzableText: input.analyzableText,
+        metadata: input.metadata
+    }))
+        .digest("hex");
+}

package/dist/src/domain/source.js

@@ -0,0 +1,93 @@
+const SOURCE_KEYS = ["id", "platform", "adapter", "target", "enabled", "notes"];
+const REGISTRY_KEYS = ["sources"];
+export class SourceRegistryValidationError extends Error {
+    issues;
+    constructor(issues) {
+        super(`Invalid Source Registry:\n${issues.map((issue) => `- ${issue}`).join("\n")}`);
+        this.name = "SourceRegistryValidationError";
+        this.issues = issues;
+    }
+}
+export function parseSourceRegistry(value) {
+    const issues = [];
+    if (!isRecord(value)) {
+        throw new SourceRegistryValidationError(["registry must be a mapping with a sources list"]);
+    }
+    collectUnknownKeys("registry", value, REGISTRY_KEYS, issues);
+    if (!Array.isArray(value.sources)) {
+        throw new SourceRegistryValidationError([...issues, "sources must be a list"]);
+    }
+    const sourceIds = new Set();
+    const sources = value.sources.flatMap((entry, index) => {
+        const prefix = `sources[${index}]`;
+        const parsed = parseSource(entry, prefix, issues);
+        if (!parsed) {
+            return [];
+        }
+        if (sourceIds.has(parsed.id)) {
+            issues.push(`${prefix}.id duplicates another Source id: ${parsed.id}`);
+        }
+        sourceIds.add(parsed.id);
+        return [parsed];
+    });
+    if (issues.length > 0) {
+        throw new SourceRegistryValidationError(issues);
+    }
+    return { sources };
+}
+function parseSource(value, prefix, issues) {
+    if (!isRecord(value)) {
+        issues.push(`${prefix} must be a mapping`);
+        return undefined;
+    }
+    collectUnknownKeys(prefix, value, SOURCE_KEYS, issues);
+    const id = readRequiredString(value, "id", prefix, issues);
+    const platform = readRequiredString(value, "platform", prefix, issues);
+    const adapter = readRequiredString(value, "adapter", prefix, issues);
+    const target = readRequiredString(value, "target", prefix, issues);
+    const enabled = readRequiredBoolean(value, "enabled", prefix, issues);
+    const notes = readRequiredString(value, "notes", prefix, issues);
+    if (!id || !platform || !adapter || !target || enabled === undefined || !notes) {
+        return undefined;
+    }
+    return {
+        id,
+        platform,
+        adapter,
+        target,
+        enabled,
+        notes
+    };
+}
+function readRequiredString(source, key, prefix, issues) {
+    const value = source[key];
+    if (typeof value !== "string") {
+        issues.push(`${prefix}.${key} must be a string`);
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        issues.push(`${prefix}.${key} must not be empty`);
+        return undefined;
+    }
+    return trimmed;
+}
+function readRequiredBoolean(source, key, prefix, issues) {
+    const value = source[key];
+    if (typeof value !== "boolean") {
+        issues.push(`${prefix}.${key} must be a boolean`);
+        return undefined;
+    }
+    return value;
+}
+function collectUnknownKeys(prefix, value, allowedKeys, issues) {
+    const allowed = new Set(allowedKeys);
+    for (const key of Object.keys(value)) {
+        if (!allowed.has(key)) {
+            issues.push(`${prefix}.${key} is not allowed in the Source Registry`);
+        }
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/src/storage/agent-run-artifact.js

@@ -0,0 +1,44 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { dirname, join } from "node:path";
+import { formatDateKey, resolveDailyBriefPaths } from "../config/index.js";
+export function createAgentRunArtifact(input) {
+    const startedAt = input.startedAt ?? new Date();
+    return {
+        schemaVersion: 1,
+        runId: input.runId ?? createAgentRunId(startedAt),
+        date: input.dateKey ?? formatDateKey(input.date),
+        startedAt: startedAt.toISOString(),
+        model: {
+            provider: input.modelRuntimeConfig.provider,
+            model: input.modelRuntimeConfig.model,
+            ...(input.modelRuntimeConfig.credentialRef ? { credentialRef: input.modelRuntimeConfig.credentialRef } : {})
+        },
+        inputRefs: input.inputRefs ?? {},
+        stages: []
+    };
+}
+export async function writeAgentRunArtifact(artifact, date, root = resolveDailyBriefPaths().agentRunRoot, dateKey) {
+    const completed = {
+        ...artifact,
+        completedAt: artifact.completedAt ?? new Date().toISOString()
+    };
+    const path = agentRunArtifactPath(date, completed.runId, root, dateKey ?? completed.date);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify(completed, null, 2)}\n`, { encoding: "utf8", flag: "wx" });
+    return { path, artifact: completed };
+}
+export async function readAgentRunArtifact(path) {
+    return JSON.parse(await readFile(path, "utf8"));
+}
+export function agentRunArtifactPath(date, runId, root = resolveDailyBriefPaths().agentRunRoot, dateKey) {
+    const datePart = dateKey ?? formatDateKey(date);
+    const [year, month] = datePart.split("-");
+    if (!year || !month) {
+        throw new Error(`Invalid Agent Run Artifact date: ${datePart}`);
+    }
+    return join(root, year, month, datePart, `${runId}.json`);
+}
+function createAgentRunId(date) {
+    return `${date.toISOString().replace(/[:.]/g, "-")}-${randomUUID()}`;
+}

package/dist/src/storage/brief-archive.js

@@ -0,0 +1,17 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { formatDateKey, resolveDailyBriefPaths } from "../config/index.js";
+export async function writeBriefArchive(markdown, date, root = resolveDailyBriefPaths().briefArchiveRoot, dateKey) {
+    const path = briefArchivePath(date, root, dateKey);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, markdown, "utf8");
+    return { path };
+}
+export function briefArchivePath(date, root = resolveDailyBriefPaths().briefArchiveRoot, dateKey) {
+    const datePart = dateKey ?? formatDateKey(date);
+    const [year, month] = datePart.split("-");
+    if (!year || !month) {
+        throw new Error(`Invalid archive date: ${datePart}`);
+    }
+    return join(root, year, month, `${datePart}.md`);
+}

package/dist/src/storage/index.js

@@ -0,0 +1,3 @@
+export * from "./agent-run-artifact.js";
+export * from "./brief-archive.js";
+export * from "./source-item-store.js";