@chenpengfei/daily-brief 0.1.0

package/dist/src/agent/signal-narrative.js

@@ -0,0 +1,247 @@
+import { Agent } from "@earendil-works/pi-agent-core";
+import { createStageModelRuntime } from "./model-stage-runtime.js";
+export async function enrichDailyBriefNarrativeWithAgent(input) {
+    const request = buildNarrativeRequest(input.brief, input.sourceItems);
+    const runtime = createStageModelRuntime({
+        config: input.modelRuntimeConfig,
+        env: input.modelRuntimeEnv ?? process.env,
+        fauxResponse: JSON.stringify(buildFauxNarrativeResponse(request))
+    });
+    try {
+        const response = await runNarrativeAgent(request, runtime);
+        const narrative = parseNarrativeResponse(response.text);
+        return {
+            brief: applyNarratives(input.brief, narrative),
+            events: response.events
+        };
+    }
+    finally {
+        runtime.unregister?.();
+    }
+}
+function buildNarrativeRequest(brief, sourceItems) {
+    const itemsById = new Map(sourceItems.map((item) => [item.id, item]));
+    return {
+        signals: brief.signals.map((signal) => ({
+            id: signal.id,
+            type: signal.type,
+            title: signal.title,
+            currentFallback: {
+                summary: signal.summary,
+                whyItMatters: signal.whyItMatters
+            },
+            citedSourceItems: signal.citations.flatMap((citation) => {
+                const item = itemsById.get(citation.sourceItemId);
+                if (!item) {
+                    return [];
+                }
+                return [
+                    {
+                        id: item.id,
+                        sourceId: item.sourceId,
+                        platform: item.platform,
+                        url: item.url,
+                        title: item.title,
+                        ...(item.author ? { author: item.author } : {}),
+                        ...(item.publishedAt ? { publishedAt: item.publishedAt } : {}),
+                        analyzableText: item.analyzableText,
+                        ...(item.metadata ? { metadata: item.metadata } : {})
+                    }
+                ];
+            })
+        }))
+    };
+}
+async function runNarrativeAgent(request, runtime) {
+    const events = [];
+    const agent = new Agent({
+        initialState: {
+            systemPrompt: [
+                "你是 Daily Brief Agent 的 Signal narrative 子任务。",
+                "你必须只基于用户提供的 cited Source Items 理解内容，生成读者可用的中文说明。",
+                "不要做开放研究，不要补充未引用事实，不要把 GitHub trending 当作质量背书。",
+                "保留项目名、库名、关键英文技术词。输出必须是 JSON object，不要 Markdown，不要解释。"
+            ].join("\n"),
+            model: runtime.model,
+            thinkingLevel: runtime.thinkingLevel
+        },
+        sessionId: "daily-brief-signal-narrative",
+        ...(runtime.getApiKey ? { getApiKey: runtime.getApiKey } : {})
+    });
+    agent.subscribe((event) => {
+        events.push(`signal_narrative:${event.type}`);
+    });
+    await agent.prompt([
+        "请为每个 Signal 生成 narrative 字段。",
+        "",
+        "JSON schema:",
+        "{",
+        "  \"executiveSummary\": \"一句简洁中文 Executive Summary\",",
+        "  \"signalNarratives\": [",
+        "    {",
+        "      \"signalId\": \"signal id from input\",",
+        "      \"focusAreas\": [\"Agent 架构|AI Coding\"],",
+        "      \"directions\": [\"先进工具|长程任务|持续学习|自我改进|人与 Agent 的边界\"],",
+        "      \"whatItIs\": \"是什么：一句中文，说明它到底是什么\",",
+        "      \"whatItIsNot\": \"不是什么：一句中文，澄清容易误解的边界\",",
+        "      \"minimalExample\": \"最小例子：一句中文，用最小具体场景帮助理解\",",
+        "      \"whyItMatters\": \"为什么重要：一句中文，具体说明它对 Agent Architecture 或 AI Coding 的意义\"",
+        "    }",
+        "  ]",
+        "}",
+        "",
+        "质量要求:",
+        "- 不要复述模板句。",
+        "- whyItMatters 必须具体到这个 Signal，不能只说“可能改变工具链”。",
+        "- whatItIsNot 不是否定项目价值，而是防止误读。",
+        "- minimalExample 要足够小，小到今天读者可以立刻想象怎么验证。",
+        "- 如果 Source Item 信息不足，明确写“当前 Source Item 只表明...”。",
+        "- 不要写“从 X 扩展到 Y”“正在走向...”这类演进判断，除非 cited Source Items 同时支撑 X 和 Y。",
+        "- 不要把 IDE 补全、长期维护、代码审查、harness 运行时调度等常见 AI Coding 背景知识写进 narrative，除非 cited Source Items 明确提到。",
+        "- minimalExample 只能使用 cited Source Items 明确描述的能力；不要发明 harness 何时调用 skill 之类的执行机制。",
+        "- whyItMatters 可以说明它对设计者提出了什么检查点，但不能声称它已经支撑未被 cited Source Items 直接提到的 workflow。",
+        "",
+        "Input:",
+        JSON.stringify(request, null, 2)
+    ].join("\n"));
+    const text = latestAssistantText(agent);
+    if (!text) {
+        throw new Error("Signal narrative Agent did not return text");
+    }
+    return { text, events };
+}
+function latestAssistantText(agent) {
+    const assistantMessage = [...agent.state.messages].reverse().find((message) => message.role === "assistant");
+    const text = assistantMessage?.content
+        .filter((block) => block.type === "text")
+        .map((block) => block.text)
+        .join("");
+    return text && text.trim().length > 0 ? text.trim() : undefined;
+}
+function parseNarrativeResponse(text) {
+    const jsonText = extractJsonObject(text);
+    const parsed = JSON.parse(jsonText);
+    if (!isRecord(parsed)) {
+        throw new Error("Signal narrative Agent returned non-object JSON");
+    }
+    return {
+        executiveSummary: readRequiredString(parsed, "executiveSummary"),
+        signalNarratives: readSignalNarrativeArray(parsed.signalNarratives)
+    };
+}
+function extractJsonObject(text) {
+    const withoutFence = text
+        .replace(/^```(?:json)?\s*/i, "")
+        .replace(/\s*```$/i, "")
+        .trim();
+    const start = withoutFence.indexOf("{");
+    const end = withoutFence.lastIndexOf("}");
+    if (start < 0 || end < start) {
+        throw new Error("Signal narrative Agent returned invalid JSON");
+    }
+    return withoutFence.slice(start, end + 1);
+}
+function readSignalNarrativeArray(value) {
+    if (!Array.isArray(value)) {
+        throw new Error("Signal narrative Agent requires signalNarratives array");
+    }
+    return value.map(parseSignalNarrative);
+}
+function parseSignalNarrative(value) {
+    if (!isRecord(value)) {
+        throw new Error("Signal narrative item must be an object");
+    }
+    return {
+        signalId: readRequiredString(value, "signalId"),
+        focusAreas: readRequiredStringArray(value, "focusAreas"),
+        directions: readRequiredStringArray(value, "directions"),
+        whatItIs: readRequiredString(value, "whatItIs"),
+        whatItIsNot: readRequiredString(value, "whatItIsNot"),
+        minimalExample: readRequiredString(value, "minimalExample"),
+        whyItMatters: readRequiredString(value, "whyItMatters")
+    };
+}
+function applyNarratives(brief, narrativeResponse) {
+    const bySignalId = new Map(narrativeResponse.signalNarratives.map((narrative) => [narrative.signalId, narrative]));
+    return {
+        ...brief,
+        executiveSummary: narrativeResponse.executiveSummary,
+        signals: brief.signals.map((signal) => {
+            const narrative = bySignalId.get(signal.id);
+            if (!narrative) {
+                throw new Error(`Signal narrative Agent omitted ${signal.id}`);
+            }
+            return {
+                ...signal,
+                focusAreas: narrative.focusAreas,
+                directions: narrative.directions,
+                summary: {
+                    whatItIs: narrative.whatItIs,
+                    whatItIsNot: narrative.whatItIsNot,
+                    minimalExample: narrative.minimalExample
+                },
+                whyItMatters: narrative.whyItMatters
+            };
+        })
+    };
+}
+function buildFauxNarrativeResponse(request) {
+    return {
+        executiveSummary: request.signals.length === 0
+            ? "今天是 low-signal day：Agent Stages 没有选出足够强、可由 Source Items 支撑的 Signals。"
+            : `今天有 ${request.signals.length} 个 Agent-generated Signals，重点围绕 Agent 架构与 AI Coding 的可回溯变化。`,
+        signalNarratives: request.signals.map((signal) => {
+            const sourceText = signal.citedSourceItems[0]?.analyzableText ?? signal.title;
+            return {
+                signalId: signal.id,
+                focusAreas: inferFocusAreas(signal),
+                directions: inferDirections(signal),
+                whatItIs: `当前 Source Item 表明：${sourceText}`,
+                whatItIsNot: `它不是对 ${signal.title} 的成熟度背书；只是本次来源中可回溯的一条 ${signal.type} Signal。`,
+                minimalExample: `最小例子：围绕 ${signal.title} 选一个 README 或小任务，验证它描述的能力是否成立。`,
+                whyItMatters: `它值得关注，因为 ${signal.title} 暴露了一个可检查的 Agent Architecture 或 AI Coding 实践切面。`
+            };
+        })
+    };
+}
+function readRequiredString(source, key) {
+    const value = source[key];
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`Signal narrative item requires ${key}`);
+    }
+    return value.trim();
+}
+function readRequiredStringArray(source, key) {
+    const value = source[key];
+    if (!Array.isArray(value) || value.length === 0 || value.some((entry) => typeof entry !== "string" || entry.trim().length === 0)) {
+        throw new Error(`Signal narrative item requires ${key}`);
+    }
+    return value.map((entry) => String(entry).trim());
+}
+function inferFocusAreas(signal) {
+    if (signal.type === "ai-coding") {
+        return ["AI Coding"];
+    }
+    if (signal.type === "architecture") {
+        return ["Agent 架构"];
+    }
+    return ["Agent 架构", "AI Coding"];
+}
+function inferDirections(signal) {
+    const text = `${signal.title} ${signal.citedSourceItems.map((item) => item.analyzableText).join(" ")}`.toLowerCase();
+    const directions = [];
+    if (signal.type === "tool-repo" || text.includes("tool"))
+        directions.push("先进工具");
+    if (text.includes("long") || text.includes("workflow"))
+        directions.push("长程任务");
+    if (text.includes("learning"))
+        directions.push("持续学习");
+    if (text.includes("improve") || text.includes("optimization"))
+        directions.push("自我改进");
+    if (text.includes("human") || text.includes("boundary"))
+        directions.push("人与 Agent 的边界");
+    return directions.length > 0 ? directions : ["先进工具"];
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/src/agent/signal-selection-ranking.js

@@ -0,0 +1,276 @@
+import { Agent } from "@earendil-works/pi-agent-core";
+import { createStageModelRuntime } from "./model-stage-runtime.js";
+import { runAgentStage } from "./stage-runner.js";
+export async function runSignalSelectionAndRankingStages(input) {
+    const modelRuntimeConfig = input.modelRuntimeConfig ?? {
+        provider: "faux",
+        model: "faux-daily-brief-renderer",
+        ready: true,
+        issues: []
+    };
+    const modelRuntimeEnv = input.modelRuntimeEnv ?? process.env;
+    const selectionRequest = buildSelectionRequest(input.sourceItems, input.annotations);
+    const selectionRuntime = createStageModelRuntime({
+        config: modelRuntimeConfig,
+        env: modelRuntimeEnv,
+        fauxResponse: JSON.stringify(buildFauxSelectionOutput(selectionRequest))
+    });
+    const selectionResponse = await runSelectionAgent(selectionRequest, selectionRuntime);
+    const selectionStage = await runAgentStage({
+        stage: "selection",
+        artifact: input.artifact,
+        inputRefs: { ...(input.inputRefs ?? {}), sourceItemIds: input.sourceItems.map((item) => item.id) },
+        validationContext: { sourceItemIds: input.sourceItems.map((item) => item.id) },
+        execute: async () => selectionResponse.text
+    });
+    const merged = mergeCandidateSignals(selectionStage.output.candidateSignals);
+    const rankingRequest = { maxSignals: input.maxSignals ?? 5, candidateSignals: merged };
+    const rankingRuntime = createStageModelRuntime({
+        config: modelRuntimeConfig,
+        env: modelRuntimeEnv,
+        fauxResponse: JSON.stringify(buildFauxRankingOutput(rankingRequest))
+    });
+    const rankingResponse = await runRankingAgent(rankingRequest, rankingRuntime);
+    const rankingStage = await runAgentStage({
+        stage: "ranking",
+        artifact: input.artifact,
+        inputRefs: {
+            ...(input.inputRefs ?? {}),
+            sourceItemIds: unique(merged.flatMap((signal) => signal.sourceItemIds)),
+            signalIds: merged.map((signal) => signal.signalId)
+        },
+        validationContext: { signalIds: merged.map((signal) => signal.signalId) },
+        execute: async () => rankingResponse.text
+    });
+    return {
+        signals: buildSignalsFromRanking(input.sourceItems, merged, rankingStage.output),
+        selection: selectionStage.output,
+        ranking: rankingStage.output,
+        events: [...selectionResponse.events, ...rankingResponse.events]
+    };
+}
+function buildSelectionRequest(sourceItems, annotations) {
+    return {
+        sourceItems: sourceItems.map((item) => ({
+            id: item.id,
+            sourceId: item.sourceId,
+            platform: item.platform,
+            url: item.url,
+            title: item.title,
+            analyzableText: item.analyzableText
+        })),
+        annotations
+    };
+}
+async function runSelectionAgent(request, runtime) {
+    const events = [];
+    const agent = new Agent({
+        initialState: {
+            systemPrompt: [
+                "你是 Daily Brief Agent 的 Signal Selection Stage。",
+                "你必须基于 Understanding annotations 和 Source Items 选择候选 Signal。",
+                "不要使用关键词兜底，不要按数组顺序照搬；候选必须能被 sourceItemIds 支撑。",
+                "输出必须是 JSON object。"
+            ].join("\n"),
+            model: runtime.model,
+            thinkingLevel: runtime.thinkingLevel
+        },
+        sessionId: "daily-brief-signal-selection",
+        ...(runtime.getApiKey ? { getApiKey: runtime.getApiKey } : {})
+    });
+    agent.subscribe((event) => {
+        events.push(`selection:${event.type}`);
+    });
+    await agent.prompt([
+        "请选择 Daily Brief 候选 Signals，并排除弱或不相关 Source Items。",
+        "",
+        "JSON schema:",
+        "{",
+        "  \"stage\": \"selection\",",
+        "  \"candidateSignals\": [",
+        "    {",
+        "      \"signalId\": \"stable unique signal id\",",
+        "      \"title\": \"reader-facing title\",",
+        "      \"signalType\": \"architecture|ai-coding|tool-repo|risk\",",
+        "      \"strength\": \"strong|weak\",",
+        "      \"sourceItemIds\": [\"cited source item ids\"],",
+        "      \"reason\": \"why this is a candidate, grounded in annotations\"",
+        "    }",
+        "  ],",
+        "  \"excludedSourceItems\": [{ \"sourceItemId\": \"id\", \"reason\": \"why excluded\" }]",
+        "}",
+        "",
+        "Selection lens: 领域包括 Agent 架构、AI Coding；方向包括先进工具、长程任务、持续学习、自我改进、人与 Agent 的边界。",
+        "Merge near-duplicate candidates yourself by using the same signalId and multiple sourceItemIds.",
+        "Title rules:",
+        "- title 只能概括 cited Source Items 直接共同说明的对象或能力。",
+        "- 不要在 title 中写“正在成为”“趋势”“继续升温”“生态演进”“走向”等 adoption/evolution 判断，除非输入 Source Items 直接证明这种变化。",
+        "- 如果只有若干 repository observations，title 应写成“X 类项目/能力出现于本次 Source Items”，而不是宣称整个生态变化。",
+        "",
+        "Input:",
+        JSON.stringify(request, null, 2)
+    ].join("\n"));
+    const text = latestAssistantText(agent);
+    if (!text) {
+        throw new Error("Selection Stage did not return text");
+    }
+    return { text, events };
+}
+async function runRankingAgent(request, runtime) {
+    const events = [];
+    const agent = new Agent({
+        initialState: {
+            systemPrompt: [
+                "你是 Daily Brief Agent 的 Signal Ranking Stage。",
+                "你必须从候选 Signals 中决定最终排序和 low-signal 结果。",
+                "不要补充候选外 Signal；如果候选不足或都弱，返回空 rankedSignals。",
+                "输出必须是 JSON object。"
+            ].join("\n"),
+            model: runtime.model,
+            thinkingLevel: runtime.thinkingLevel
+        },
+        sessionId: "daily-brief-signal-ranking",
+        ...(runtime.getApiKey ? { getApiKey: runtime.getApiKey } : {})
+    });
+    agent.subscribe((event) => {
+        events.push(`ranking:${event.type}`);
+    });
+    await agent.prompt([
+        "请对候选 Signals 排序，最多选择 maxSignals 个 strong signals。",
+        "",
+        "JSON schema:",
+        "{",
+        "  \"stage\": \"ranking\",",
+        "  \"rankedSignals\": [{ \"signalId\": \"candidate signal id\", \"rank\": 1, \"reason\": \"grounded ranking reason\" }]",
+        "}",
+        "",
+        "Input:",
+        JSON.stringify(request, null, 2)
+    ].join("\n"));
+    const text = latestAssistantText(agent);
+    if (!text) {
+        throw new Error("Ranking Stage did not return text");
+    }
+    return { text, events };
+}
+export function mergeCandidateSignals(candidates) {
+    const byId = new Map();
+    for (const candidate of candidates) {
+        const previous = byId.get(candidate.signalId);
+        if (!previous) {
+            byId.set(candidate.signalId, { ...candidate, sourceItemIds: unique(candidate.sourceItemIds) });
+            continue;
+        }
+        byId.set(candidate.signalId, {
+            ...previous,
+            strength: previous.strength === "strong" || candidate.strength === "strong" ? "strong" : "weak",
+            sourceItemIds: unique([...previous.sourceItemIds, ...candidate.sourceItemIds]),
+            reason: unique([previous.reason, candidate.reason]).join(" / ")
+        });
+    }
+    return [...byId.values()];
+}
+function buildFauxSelectionOutput(request) {
+    const itemById = new Map(request.sourceItems.map((item) => [item.id, item]));
+    const candidateSignals = [];
+    const excludedSourceItems = [];
+    for (const annotation of request.annotations) {
+        const item = itemById.get(annotation.sourceItemId);
+        if (!item) {
+            continue;
+        }
+        if (annotation.relevance === "relevant" && annotation.focusAreaRelevance !== "none") {
+            candidateSignals.push({
+                signalId: `signal:${item.url.trim().toLowerCase()}`,
+                title: item.title,
+                signalType: inferSignalType(item, annotation),
+                strength: annotation.focusAreaRelevance === "strong" || annotation.focusAreaRelevance === "partial" ? "strong" : "weak",
+                sourceItemIds: [item.id],
+                reason: annotation.summary
+            });
+        }
+        else {
+            excludedSourceItems.push({
+                sourceItemId: item.id,
+                reason: annotation.weakItemHints[0] ?? "Understanding Stage judged this Source Item too weak for a Signal."
+            });
+        }
+    }
+    return { stage: "selection", candidateSignals, excludedSourceItems };
+}
+function buildFauxRankingOutput(request) {
+    const strong = request.candidateSignals.filter((candidate) => candidate.strength === "strong");
+    return {
+        stage: "ranking",
+        rankedSignals: strong.slice(0, request.maxSignals).map((candidate, index) => ({
+            signalId: candidate.signalId,
+            rank: index + 1,
+            reason: candidate.reason
+        }))
+    };
+}
+function buildSignalsFromRanking(sourceItems, candidates, ranking) {
+    const itemById = new Map(sourceItems.map((item) => [item.id, item]));
+    const candidateById = new Map(candidates.map((candidate) => [candidate.signalId, candidate]));
+    return ranking.rankedSignals.flatMap((ranked) => {
+        const candidate = candidateById.get(ranked.signalId);
+        if (!candidate) {
+            return [];
+        }
+        const citedItems = candidate.sourceItemIds.flatMap((id) => {
+            const item = itemById.get(id);
+            return item ? [item] : [];
+        });
+        const citations = citedItems.map((item) => ({
+            sourceItemId: item.id,
+            sourceId: item.sourceId,
+            title: item.title,
+            url: item.url
+        }));
+        const first = citedItems[0];
+        if (!first) {
+            return [];
+        }
+        return [
+            {
+                id: candidate.signalId,
+                type: candidate.signalType ?? inferSignalType(first),
+                title: candidate.title,
+                summary: summarizeSelectedSignal(first, candidate.reason),
+                whyItMatters: ranked.reason,
+                citations
+            }
+        ];
+    });
+}
+function summarizeSelectedSignal(item, reason) {
+    return {
+        whatItIs: item.platform === "github" ? `它是一个 GitHub repository：${reason}` : `它是一个 Source-grounded Signal：${reason}`,
+        whatItIsNot: "不是未引用来源支撑的通用判断；当前只代表 Selection/Ranking Stages 基于 cited Source Items 选出的 Signal。",
+        minimalExample: "最小地看，先回到 citations 中的 Source Item，确认这个判断是否被原文直接支撑。"
+    };
+}
+function inferSignalType(item, annotation) {
+    const text = `${item.title} ${item.analyzableText} ${annotation?.claims.join(" ") ?? ""}`.toLowerCase();
+    if (text.includes("risk") || text.includes("failure") || text.includes("security")) {
+        return "risk";
+    }
+    if (text.includes("coding agent") || text.includes("ai coding")) {
+        return "ai-coding";
+    }
+    if (item.platform === "github" || text.includes("repo")) {
+        return "tool-repo";
+    }
+    return "architecture";
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+function latestAssistantText(agent) {
+    const assistantMessage = [...agent.state.messages].reverse().find((message) => message.role === "assistant");
+    const text = assistantMessage?.content
+        .filter((block) => block.type === "text")
+        .map((block) => block.text)
+        .join("");
+    return text && text.trim().length > 0 ? text.trim() : undefined;
+}

package/dist/src/agent/source-grounding-audit.js

@@ -0,0 +1,148 @@
+import { Agent } from "@earendil-works/pi-agent-core";
+import { createStageModelRuntime } from "./model-stage-runtime.js";
+import { runAgentStage } from "./stage-runner.js";
+export class AnalysisFailureError extends Error {
+    findings;
+    constructor(message, findings) {
+        super(message);
+        this.name = "AnalysisFailureError";
+        this.findings = findings;
+    }
+}
+export async function runSourceGroundingAuditStage(input) {
+    const modelRuntimeConfig = input.modelRuntimeConfig ?? {
+        provider: "faux",
+        model: "faux-daily-brief-renderer",
+        ready: true,
+        issues: []
+    };
+    const first = await recordAudit(input.brief, input.sourceItems, input.artifact, modelRuntimeConfig, input.modelRuntimeEnv ?? process.env, input.inputRefs);
+    if (first.status === "passed") {
+        return { brief: input.brief, audit: first, repairAttempts: 0 };
+    }
+    throw new AnalysisFailureError("Source-grounding audit failed", first.findings);
+}
+async function recordAudit(brief, sourceItems, artifact, modelRuntimeConfig, modelRuntimeEnv, inputRefs) {
+    const sourceItemIds = sourceItems.map((item) => item.id);
+    const signalIds = brief.signals.map((signal) => signal.id);
+    const request = buildAuditRequest(brief, sourceItems);
+    const runtime = createStageModelRuntime({
+        config: modelRuntimeConfig,
+        env: modelRuntimeEnv,
+        fauxResponse: JSON.stringify(buildFauxAuditOutput(brief, sourceItems))
+    });
+    const response = await runAuditAgent(request, runtime);
+    const result = await runAgentStage({
+        stage: "audit",
+        artifact,
+        inputRefs: { ...(inputRefs ?? {}), sourceItemIds, signalIds },
+        validationContext: { sourceItemIds, signalIds },
+        execute: async () => response.text
+    });
+    return result.output;
+}
+function buildAuditRequest(brief, sourceItems) {
+    return {
+        brief,
+        citedSourceItems: sourceItems.map((item) => ({
+            id: item.id,
+            sourceId: item.sourceId,
+            platform: item.platform,
+            url: item.url,
+            title: item.title,
+            analyzableText: item.analyzableText,
+            ...(item.metadata ? { metadata: item.metadata } : {})
+        }))
+    };
+}
+async function runAuditAgent(request, runtime) {
+    const events = [];
+    const agent = new Agent({
+        initialState: {
+            systemPrompt: [
+                "你是 Daily Brief Agent 的 Source-grounding Audit Stage。",
+                "你必须审查 brief 中每个 narrative 是否被 cited Source Items 支撑。",
+                "重点检查 unsupported claims、generic AI drift、open-ended research leakage、citation mismatch、coverage overstatement。",
+                "不要修复 brief，只输出 audit JSON。"
+            ].join("\n"),
+            model: runtime.model,
+            thinkingLevel: runtime.thinkingLevel
+        },
+        sessionId: "daily-brief-source-grounding-audit",
+        ...(runtime.getApiKey ? { getApiKey: runtime.getApiKey } : {})
+    });
+    agent.subscribe((event) => {
+        events.push(`audit:${event.type}`);
+    });
+    await agent.prompt([
+        "请审查 Daily Brief 是否 Source-grounded。",
+        "",
+        "JSON schema:",
+        "{",
+        "  \"stage\": \"audit\",",
+        "  \"status\": \"passed|failed\",",
+        "  \"findings\": [{ \"signalId\": \"optional known signal id\", \"sourceItemId\": \"optional known source item id\", \"issue\": \"specific issue\" }]",
+        "}",
+        "",
+        "如果无法确认某个强断言被 cited Source Item 支撑，必须 failed。",
+        "如果 Source Coverage 有 partial failures，Executive Summary 不得声称完整覆盖。",
+        "Source Coverage 的 Processed N Source Items from M Sources 是运行覆盖统计，不表示 Top Signals 必须叙述每个 Source Item；不要因为未引用所有 Source Items 而 failed。",
+        "whyItMatters 和 minimalExample 可以包含基于 cited facts 的有限读者含义或设计检查点；只要它没有引入外部事实、质量背书、采用趋势或未支撑能力，不要仅因 Source Item 没有逐字说“设计者需要...”而 failed。",
+        "对规范性措辞的审查重点是是否越过 cited facts：例如“必须采用”“已经成熟”“广泛使用”需要直接支撑；“提醒设计者检查...”这类弱含义可由 cited capabilities 支撑。",
+        "",
+        "Input:",
+        JSON.stringify(request, null, 2)
+    ].join("\n"));
+    const text = latestAssistantText(agent);
+    if (!text) {
+        throw new Error("Audit Stage did not return text");
+    }
+    return { text, events };
+}
+function buildFauxAuditOutput(brief, sourceItems) {
+    const sourceItemIds = new Set(sourceItems.map((item) => item.id));
+    const findings = [];
+    if (brief.sourceCoverage.partialFailures.length > 0 && /全部|完整|all sources|complete/i.test(brief.executiveSummary)) {
+        findings.push({ issue: "Executive Summary overstates collection completeness despite partial failures." });
+    }
+    for (const signal of brief.signals) {
+        if (signal.citations.length === 0) {
+            findings.push({ signalId: signal.id, issue: "Signal has no citations." });
+        }
+        if (!signal.focusAreas || signal.focusAreas.length === 0) {
+            findings.push({ signalId: signal.id, issue: "Signal lens focusAreas are missing." });
+        }
+        if (!signal.directions || signal.directions.length === 0) {
+            findings.push({ signalId: signal.id, issue: "Signal lens directions are missing." });
+        }
+        for (const citation of signal.citations) {
+            if (!sourceItemIds.has(citation.sourceItemId)) {
+                findings.push({
+                    signalId: signal.id,
+                    issue: `Citation references unknown Source Item: ${citation.sourceItemId}`
+                });
+            }
+        }
+        const narrative = `${signal.summary.whatItIs} ${signal.summary.whatItIsNot} ${signal.summary.minimalExample} ${signal.whyItMatters}`;
+        if (/market leader|guaranteed|best in class|widely adopted/i.test(narrative)) {
+            findings.push({ signalId: signal.id, issue: "Narrative contains unsupported overconfident claim." });
+        }
+        if (signal.citations.length > 1 &&
+            /分别(?:指向|对应|代表|说明|表明|描述)|一一对应|respectively/i.test(narrative)) {
+            findings.push({ signalId: signal.id, issue: "Narrative contains risky per-source mapping across multiple citations." });
+        }
+    }
+    return {
+        stage: "audit",
+        status: findings.length === 0 ? "passed" : "failed",
+        findings
+    };
+}
+function latestAssistantText(agent) {
+    const assistantMessage = [...agent.state.messages].reverse().find((message) => message.role === "assistant");
+    const text = assistantMessage?.content
+        .filter((block) => block.type === "text")
+        .map((block) => block.text)
+        .join("");
+    return text && text.trim().length > 0 ? text.trim() : undefined;
+}