nodebench-mcp 2.44.0 → 2.46.0

package/dist/tools/founderTools.js

@@ -10,6 +10,116 @@
  * every piece of context it needs.
  */
 import { getDb } from "../db.js";
+/* ------------------------------------------------------------------ */
+/*  founder_packets schema bootstrap (idempotent)                      */
+/* ------------------------------------------------------------------ */
+let _packetSchemaReady = false;
+function ensurePacketSchema() {
+    if (_packetSchemaReady)
+        return;
+    const db = getDb();
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS founder_packets (
+      id          INTEGER PRIMARY KEY AUTOINCREMENT,
+      packetId    TEXT UNIQUE NOT NULL,
+      entityId    TEXT NOT NULL,
+      packetType  TEXT NOT NULL,
+      packetJson  TEXT NOT NULL,
+      createdAt   TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_founder_packets_entity ON founder_packets(entityId);
+    CREATE INDEX IF NOT EXISTS idx_founder_packets_type ON founder_packets(packetType);
+    CREATE INDEX IF NOT EXISTS idx_founder_packets_created ON founder_packets(createdAt);
+  `);
+    _packetSchemaReady = true;
+}
+/* ------------------------------------------------------------------ */
+/*  JSON flatten / diff helpers                                        */
+/* ------------------------------------------------------------------ */
+/** Flatten a nested object into dot-notation paths. Arrays become path.0, path.1, etc. */
+function flattenObject(obj, prefix = "", out = {}) {
+    if (obj === null || obj === undefined) {
+        if (prefix)
+            out[prefix] = obj;
+        return out;
+    }
+    if (Array.isArray(obj)) {
+        if (obj.length === 0 && prefix) {
+            out[prefix] = obj;
+        }
+        for (let i = 0; i < obj.length; i++) {
+            flattenObject(obj[i], prefix ? `${prefix}.${i}` : String(i), out);
+        }
+        return out;
+    }
+    if (typeof obj === "object") {
+        const record = obj;
+        const keys = Object.keys(record);
+        if (keys.length === 0 && prefix) {
+            out[prefix] = obj;
+        }
+        for (const key of keys) {
+            flattenObject(record[key], prefix ? `${prefix}.${key}` : key, out);
+        }
+        return out;
+    }
+    // Primitive
+    if (prefix)
+        out[prefix] = obj;
+    return out;
+}
+function computePacketDiff(current, prior) {
+    const flatCurrent = flattenObject(current);
+    const flatPrior = flattenObject(prior);
+    const currentKeys = new Set(Object.keys(flatCurrent));
+    const priorKeys = new Set(Object.keys(flatPrior));
+    const newSinceLastTime = [];
+    const resolvedSinceLastTime = [];
+    const changedFields = [];
+    const stableFields = [];
+    // Fields in current but not in prior
+    for (const key of currentKeys) {
+        if (!priorKeys.has(key)) {
+            newSinceLastTime.push(key);
+        }
+    }
+    // Fields in prior but not in current
+    for (const key of priorKeys) {
+        if (!currentKeys.has(key)) {
+            resolvedSinceLastTime.push(key);
+        }
+    }
+    // Fields in both — compare values
+    for (const key of currentKeys) {
+        if (!priorKeys.has(key))
+            continue;
+        const cv = JSON.stringify(flatCurrent[key]);
+        const pv = JSON.stringify(flatPrior[key]);
+        if (cv === pv) {
+            stableFields.push(key);
+        }
+        else {
+            changedFields.push({
+                path: key,
+                previous: flatPrior[key],
+                current: flatCurrent[key],
+            });
+        }
+    }
+    // Drift score: fraction of all unique keys that differ
+    const allKeys = new Set([...currentKeys, ...priorKeys]);
+    const totalKeys = allKeys.size;
+    const diffCount = newSinceLastTime.length + resolvedSinceLastTime.length + changedFields.length;
+    const driftScore = totalKeys > 0 ? Math.round((diffCount / totalKeys) * 1000) / 1000 : 0;
+    return {
+        newSinceLastTime,
+        resolvedSinceLastTime,
+        changedFields,
+        stableFields,
+        driftScore: Math.min(driftScore, 1.0),
+    };
+}
 const GATHER_PROTOCOL = [
     {
         id: "company_identity",
@@ -219,6 +329,70 @@ const GATHER_PROTOCOL = [
     },
 ];
 /* ------------------------------------------------------------------ */
+/*  Importance scoring for event ranking                               */
+/* ------------------------------------------------------------------ */
+const EVENT_TYPE_WEIGHTS = {
+    "product.phase.completed": 0.9,
+    "contradiction.detected": 0.85,
+    "important_change.flagged": 0.8,
+    "packet.generated": 0.7,
+    "state.changed": 0.6,
+    "engine.trace.completed": 0.5,
+    "action.completed": 0.4,
+};
+const DEFAULT_EVENT_WEIGHT = 0.3;
+const RECENCY_DECAY_PER_DAY = 0.1;
+const THESIS_RELEVANCE_BOOST = 1.3;
+const IMPORTANCE_THRESHOLD = 0.3;
+function scoreEvents(rawEvents, missionKeywords) {
+    const now = Date.now();
+    const msPerDay = 24 * 60 * 60 * 1000;
+    const scored = rawEvents.map((e) => {
+        const eventType = e.eventType ?? "";
+        const baseWeight = EVENT_TYPE_WEIGHTS[eventType] ?? DEFAULT_EVENT_WEIGHT;
+        // Recency decay: today=1.0, yesterday=0.9, ...
+        const ts = e.timestamp ?? 0;
+        const daysAgo = Math.max(0, Math.floor((now - ts) / msPerDay));
+        const recencyMultiplier = Math.max(0.1, 1.0 - daysAgo * RECENCY_DECAY_PER_DAY);
+        // Thesis relevance boost
+        const summary = (e.summary ?? "").toLowerCase();
+        const matchesMission = missionKeywords.length > 0 &&
+            missionKeywords.some((kw) => summary.includes(kw));
+        const relevanceMultiplier = matchesMission ? THESIS_RELEVANCE_BOOST : 1.0;
+        const score = Math.round(baseWeight * recencyMultiplier * relevanceMultiplier * 1000) / 1000;
+        return {
+            type: e.eventType,
+            entity: e.entityId,
+            summary: e.summary,
+            actor: e.actor,
+            timestamp: e.timestamp,
+            importanceScore: score,
+        };
+    });
+    // Sort descending by score
+    scored.sort((a, b) => b.importanceScore - a.importanceScore);
+    const ranked = scored.filter((e) => e.importanceScore >= IMPORTANCE_THRESHOLD);
+    const suppressedCount = scored.length - ranked.length;
+    const topSignal = ranked[0] ?? null;
+    return { ranked, suppressedCount, topSignal };
+}
+/** Extract lowercase keywords from a mission string for fuzzy matching. */
+function extractMissionKeywords(diffs) {
+    // Pull keywords from the most recent state diff's reason/fields
+    if (diffs.length === 0)
+        return [];
+    const latest = diffs[0];
+    const reason = (latest.reason ?? "").toLowerCase();
+    const fields = (latest.changedFields ?? "").toLowerCase();
+    const combined = `${reason} ${fields}`;
+    // Split on non-alpha, filter short/stop words
+    const stopWords = new Set(["the", "and", "for", "was", "that", "with", "from", "are", "this", "has", "its", "not", "but"]);
+    return combined
+        .split(/[^a-z]+/)
+        .filter((w) => w.length > 3 && !stopWords.has(w))
+        .slice(0, 20);
+}
+/* ------------------------------------------------------------------ */
 /*  Tools                                                              */
 /* ------------------------------------------------------------------ */
 export const founderTools = [
@@ -244,6 +418,10 @@ export const founderTools = [
                     type: "string",
                     description: "Optional summary of the most recent prior packet, for temporal comparison.",
                 },
+                entityId: {
+                    type: "string",
+                    description: "Optional entity ID to scope the gather (and prior-brief lookup) to a specific company/entity.",
+                },
                 focusAreas: {
                     type: "array",
                     items: { type: "string" },
@@ -326,6 +504,10 @@ export const founderTools = [
                     .prepare("SELECT * FROM causal_trajectory_scores ORDER BY createdAt DESC LIMIT 1")
                     .all();
                 if (recentEvents.length > 0 || importantChanges.length > 0 || stateDiffs.length > 0) {
+                    // Extract mission keywords from most recent state diff for thesis relevance
+                    const missionKeywords = extractMissionKeywords(stateDiffs);
+                    // Score and rank events by importance
+                    const { ranked, suppressedCount, topSignal } = scoreEvents(recentEvents, missionKeywords);
                     sessionMemory = {
                         source: "causal_memory_auto_hydrate",
                         period: "last_7_days",
@@ -335,13 +517,9 @@ export const founderTools = [
                         weeklyActions,
                         milestones,
                         trajectory: trajectory[0] ?? null,
-                        events: recentEvents.map((e) => ({
-                            type: e.eventType,
-                            entity: e.entityId,
-                            summary: e.summary,
-                            actor: e.actor,
-                            timestamp: e.timestamp,
-                        })),
+                        topSignal,
+                        suppressedCount,
+                        events: ranked,
                         changes: importantChanges.map((c) => ({
                             category: c.changeCategory,
                             impact: c.impactScore,
@@ -360,6 +538,100 @@ export const founderTools = [
                 // causal memory tables may not exist yet — graceful fallback
                 sessionMemory = null;
             }
+            // ── Prior-brief cross-referencing for weekly_reset ──────────────
+            let priorBriefComparison = null;
+            if (packetType === "weekly_reset") {
+                try {
+                    ensurePacketSchema();
+                    const db = getDb();
+                    const entityId = args.entityId ?? null;
+                    const priorRow = entityId
+                        ? db
+                            .prepare("SELECT * FROM founder_packets WHERE entityId = ? ORDER BY createdAt DESC LIMIT 1")
+                            .get(entityId)
+                        : db
+                            .prepare("SELECT * FROM founder_packets ORDER BY createdAt DESC LIMIT 1")
+                            .get();
+                    if (priorRow) {
+                        const lastPacketDate = priorRow.createdAt;
+                        const lastPacketMs = new Date(lastPacketDate).getTime();
+                        const daysSinceLastPacket = Math.max(0, Math.round((Date.now() - lastPacketMs) / (24 * 60 * 60 * 1000)));
+                        let priorPacketData = {};
+                        try {
+                            priorPacketData = JSON.parse(priorRow.packetJson);
+                        }
+                        catch {
+                            // malformed JSON — treat as empty
+                        }
+                        // Gather changes/events from sessionMemory that are AFTER the prior packet
+                        const newSinceLastPacket = [];
+                        const stillUnresolved = [];
+                        const resolvedSinceLastPacket = [];
+                        // Classify current important changes against prior packet
+                        if (sessionMemory) {
+                            const currentChanges = (sessionMemory.changes ?? []);
+                            const currentEvents = (sessionMemory.events ?? []);
+                            // Events that occurred after the prior packet
+                            for (const evt of currentEvents) {
+                                const evtTs = evt.timestamp ?? 0;
+                                if (evtTs > lastPacketMs) {
+                                    newSinceLastPacket.push(evt);
+                                }
+                            }
+                            // Classify important changes: still unresolved vs resolved
+                            const priorChanges = (priorPacketData.whatChanged ?? priorPacketData.changes ?? []);
+                            const priorChangeIds = new Set(priorChanges.map((c) => c.id ?? c.description ?? ""));
+                            for (const change of currentChanges) {
+                                const changeKey = change.category ?? change.reason ?? "";
+                                if (change.status === "detected" || change.status === "acknowledged" || change.status === "investigating") {
+                                    stillUnresolved.push(change);
+                                }
+                            }
+                            // Prior changes no longer in current unresolved set
+                            const unresolvedKeys = new Set(stillUnresolved.map((c) => c.category ?? c.reason ?? ""));
+                            for (const pc of priorChanges) {
+                                const pcKey = pc.id ?? pc.description ?? pc.category ?? "";
+                                if (pcKey && !unresolvedKeys.has(pcKey)) {
+                                    resolvedSinceLastPacket.push(pc);
+                                }
+                            }
+                        }
+                        // Recommended focus: top 3 from (new + unresolved) ranked by impact
+                        const focusCandidates = [
+                            ...newSinceLastPacket.map((e) => ({
+                                item: e.summary ?? e.type ?? "unknown event",
+                                source: "new",
+                                impact: e.importanceScore ?? 0.5,
+                            })),
+                            ...stillUnresolved.map((c) => ({
+                                item: c.reason ?? c.category ?? "unresolved change",
+                                source: "unresolved",
+                                impact: c.impact ?? 0.5,
+                            })),
+                        ];
+                        focusCandidates.sort((a, b) => b.impact - a.impact);
+                        const recommendedFocus = focusCandidates.slice(0, 3);
+                        priorBriefComparison = {
+                            lastPacketDate,
+                            daysSinceLastPacket,
+                            priorPacketId: priorRow.packetId ?? null,
+                            priorPacketType: priorRow.packetType ?? null,
+                            newSinceLastPacket,
+                            stillUnresolved,
+                            resolvedSinceLastPacket,
+                            recommendedFocus,
+                        };
+                        // Attach to sessionMemory if it exists
+                        if (sessionMemory) {
+                            sessionMemory.priorBriefComparison = priorBriefComparison;
+                        }
+                    }
+                }
+                catch {
+                    // founder_packets table may not exist yet — graceful fallback
+                    priorBriefComparison = null;
+                }
+            }
             const protocol = {
                 protocolVersion: "1.1",
                 packetType,
@@ -367,6 +639,8 @@ export const founderTools = [
                 requiredSteps: requiredSteps.length,
                 // Pre-hydrated session memory (if available)
                 ...(sessionMemory ? { sessionMemory } : {}),
+                // Prior-brief cross-reference (weekly_reset only, null if no prior packet)
+                ...(packetType === "weekly_reset" ? { priorBriefComparison } : {}),
                 instructions: [
                     ...(sessionMemory
                         ? [
@@ -374,6 +648,11 @@ export const founderTools = [
                             "Cross-reference sessionMemory events, changes, and diffs against the gather steps below.",
                         ]
                         : []),
+                    ...(priorBriefComparison
+                        ? [
+                            "Cross-reference findings against priorBriefComparison. Highlight what's NEW vs what was already known. Do not repeat resolved items.",
+                        ]
+                        : []),
                     "You MUST complete ALL required gather steps before generating the artifact packet.",
                     "For each step, search the listed sources using the provided search patterns.",
                     "Do NOT skip a step because it seems redundant — redundancy catches blind spots.",
@@ -665,5 +944,642 @@ export const founderTools = [
             };
         },
     },
+    // ─── 4. founder_packet_history_diff ──────────────────────────────
+    {
+        name: "founder_packet_history_diff",
+        description: "Compares the most recent Founder Artifact Packet for an entity against " +
+            "prior packets stored in the founder_packets SQLite table. Returns a " +
+            "structured diff: newSinceLastTime, resolvedSinceLastTime, changedFields, " +
+            "stableFields, and a driftScore (0.0–1.0). If only one packet exists, " +
+            "returns it as a baseline. If none exist, suggests running " +
+            "founder_deep_context_gather first.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                entityId: {
+                    type: "string",
+                    description: "The entity ID to look up packets for.",
+                },
+                packetType: {
+                    type: "string",
+                    description: "Optional packet type filter (e.g. weekly_reset, pre_delegation, important_change).",
+                },
+                limit: {
+                    type: "number",
+                    description: "Max number of recent packets to retrieve for comparison (default 2, max 10).",
+                },
+            },
+            required: ["entityId"],
+        },
+        annotations: { readOnlyHint: true },
+        handler: async (args) => {
+            ensurePacketSchema();
+            const db = getDb();
+            const entityId = args.entityId;
+            const packetType = args.packetType ?? null;
+            const limit = Math.min(Math.max(args.limit ?? 2, 1), 10);
+            // Query recent packets for this entity
+            let rows;
+            if (packetType) {
+                rows = db
+                    .prepare(`SELECT packetId, entityId, packetType, packetJson, createdAt
+             FROM founder_packets
+             WHERE entityId = ? AND packetType = ?
+             ORDER BY createdAt DESC
+             LIMIT ?`)
+                    .all(entityId, packetType, limit);
+            }
+            else {
+                rows = db
+                    .prepare(`SELECT packetId, entityId, packetType, packetJson, createdAt
+             FROM founder_packets
+             WHERE entityId = ?
+             ORDER BY createdAt DESC
+             LIMIT ?`)
+                    .all(entityId, limit);
+            }
+            // No packets found
+            if (rows.length === 0) {
+                return {
+                    noPackets: true,
+                    entityId,
+                    suggestion: "Run founder_deep_context_gather first to generate and store a packet.",
+                };
+            }
+            // Parse packet JSON safely
+            const packets = rows.map((row) => {
+                let parsed = {};
+                try {
+                    parsed = JSON.parse(row.packetJson);
+                }
+                catch {
+                    parsed = { _parseError: true, raw: row.packetJson };
+                }
+                return {
+                    packetId: row.packetId,
+                    entityId: row.entityId,
+                    packetType: row.packetType,
+                    createdAt: row.createdAt,
+                    data: parsed,
+                };
+            });
+            // Only one packet — return as baseline
+            if (packets.length === 1) {
+                return {
+                    isFirstPacket: true,
+                    entityId,
+                    packet: {
+                        packetId: packets[0].packetId,
+                        packetType: packets[0].packetType,
+                        createdAt: packets[0].createdAt,
+                    },
+                    note: "First packet for this entity. Future calls will produce diffs.",
+                };
+            }
+            // 2+ packets — diff the most recent against the one before it
+            const latest = packets[0];
+            const prior = packets[1];
+            const diff = computePacketDiff(latest.data, prior.data);
+            return {
+                entityId,
+                latest: {
+                    packetId: latest.packetId,
+                    packetType: latest.packetType,
+                    createdAt: latest.createdAt,
+                },
+                prior: {
+                    packetId: prior.packetId,
+                    packetType: prior.packetType,
+                    createdAt: prior.createdAt,
+                },
+                diff: {
+                    newSinceLastTime: diff.newSinceLastTime,
+                    resolvedSinceLastTime: diff.resolvedSinceLastTime,
+                    changedFields: diff.changedFields,
+                    stableFields: diff.stableFields,
+                    driftScore: diff.driftScore,
+                },
+                summary: {
+                    totalFieldsCompared: diff.newSinceLastTime.length +
+                        diff.resolvedSinceLastTime.length +
+                        diff.changedFields.length +
+                        diff.stableFields.length,
+                    newCount: diff.newSinceLastTime.length,
+                    resolvedCount: diff.resolvedSinceLastTime.length,
+                    changedCount: diff.changedFields.length,
+                    stableCount: diff.stableFields.length,
+                    driftScore: diff.driftScore,
+                    driftLevel: diff.driftScore < 0.1
+                        ? "minimal"
+                        : diff.driftScore < 0.3
+                            ? "low"
+                            : diff.driftScore < 0.6
+                                ? "moderate"
+                                : diff.driftScore < 0.85
+                                    ? "high"
+                                    : "extreme",
+                },
+                packetsAvailable: packets.length,
+            };
+        },
+    },
+    // ─── 5. export_artifact_packet ──────────────────────────────────
+    {
+        name: "export_artifact_packet",
+        description: "Formats a Founder Artifact Packet or memo for export to a specific audience and format. " +
+            "Applies audience-specific framing (founder, investor, banker, developer, teammate) and " +
+            "renders into the requested format (markdown, html, json, plaintext). Always includes " +
+            "provenance metadata (timestamp, version, exportId) for traceability.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                content: {
+                    type: "object",
+                    description: "The raw packet/memo content to format for export.",
+                },
+                format: {
+                    type: "string",
+                    enum: ["markdown", "html", "json", "plaintext"],
+                    description: "Output format for the exported artifact.",
+                },
+                audience: {
+                    type: "string",
+                    enum: ["founder", "investor", "banker", "developer", "teammate"],
+                    description: "Target audience — controls tone, ordering, and which sections are emphasized.",
+                },
+                title: {
+                    type: "string",
+                    description: "Override title for the exported artifact. Defaults to packet title or 'Artifact Packet'.",
+                },
+                includeMetadata: {
+                    type: "boolean",
+                    description: "Include generation timestamp, tool version, and provenance block. Defaults to true.",
+                },
+            },
+            required: ["content", "format", "audience"],
+        },
+        handler: async (args) => {
+            const content = args.content;
+            const format = args.format;
+            const audience = args.audience;
+            const titleOverride = args.title ?? null;
+            const includeMetadata = args.includeMetadata ?? true;
+            const validFormats = ["markdown", "html", "json", "plaintext"];
+            const validAudiences = ["founder", "investor", "banker", "developer", "teammate"];
+            if (!validFormats.includes(format)) {
+                return {
+                    error: true,
+                    message: `Invalid format: ${format}. Must be one of: ${validFormats.join(", ")}.`,
+                };
+            }
+            if (!validAudiences.includes(audience)) {
+                return {
+                    error: true,
+                    message: `Invalid audience: ${audience}. Must be one of: ${validAudiences.join(", ")}.`,
+                };
+            }
+            const NODEBENCH_VERSION = "1.0.0";
+            const exportId = `exp_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+            const generatedAt = new Date().toISOString();
+            // ── Extract common fields from content ──────────────────────────
+            const entity = content.canonicalEntity ?? {};
+            const companyName = entity.name ?? content.companyName ?? "Unknown Company";
+            const mission = entity.mission ?? content.mission ?? "";
+            const wedge = entity.wedge ?? content.wedge ?? "";
+            const identityConfidence = entity.identityConfidence ?? null;
+            const contradictions = content.contradictions ?? [];
+            const nextActions = content.nextActions ?? [];
+            const operatingMemo = content.operatingMemo ?? "";
+            const whatChanged = content.whatChanged ?? [];
+            const nearbyEntities = content.nearbyEntities ?? [];
+            const keyEvidence = content.keyEvidence ?? [];
+            const agentInstructions = content.agentInstructions ?? null;
+            const title = titleOverride ?? content.title ?? "Artifact Packet";
+            const audienceConfigs = {
+                founder: {
+                    tone: "informal",
+                    sectionOrder: [
+                        "summary",
+                        "whatChanged",
+                        "contradictions",
+                        "nextMoves",
+                        "initiatives",
+                        "agents",
+                        "operatingMemo",
+                        "evidence",
+                    ],
+                    emphasisSections: ["contradictions", "nextMoves"],
+                    excludeSections: [],
+                    headerPrefix: "",
+                },
+                investor: {
+                    tone: "formal",
+                    sectionOrder: [
+                        "metrics",
+                        "summary",
+                        "marketContext",
+                        "risks",
+                        "initiatives",
+                        "evidence",
+                    ],
+                    emphasisSections: ["metrics", "risks"],
+                    excludeSections: ["agents", "agentInstructions"],
+                    headerPrefix: "Investment Memo: ",
+                },
+                banker: {
+                    tone: "formal",
+                    sectionOrder: [
+                        "companySnapshot",
+                        "financialSignals",
+                        "riskFactors",
+                        "comparables",
+                        "summary",
+                        "evidence",
+                    ],
+                    emphasisSections: ["companySnapshot", "financialSignals", "riskFactors"],
+                    excludeSections: ["agents", "agentInstructions", "operatingMemo"],
+                    headerPrefix: "Memo: ",
+                },
+                developer: {
+                    tone: "technical",
+                    sectionOrder: [
+                        "architectureChanges",
+                        "technicalDecisions",
+                        "apiChanges",
+                        "whatChanged",
+                        "nextMoves",
+                        "agents",
+                    ],
+                    emphasisSections: ["architectureChanges", "apiChanges"],
+                    excludeSections: ["nearbyEntities", "operatingMemo"],
+                    headerPrefix: "",
+                },
+                teammate: {
+                    tone: "conversational",
+                    sectionOrder: ["delegationBrief", "actionItems", "whatChanged", "context"],
+                    emphasisSections: ["delegationBrief", "actionItems"],
+                    excludeSections: ["evidence", "nearbyEntities"],
+                    headerPrefix: "",
+                },
+            };
+            const config = audienceConfigs[audience];
+            const sections = [];
+            // Summary / company snapshot
+            if (audience === "banker") {
+                sections.push({
+                    key: "companySnapshot",
+                    heading: "Company Snapshot",
+                    body: [
+                        companyName ? `Company: ${companyName}` : "",
+                        mission ? `Mission: ${mission}` : "",
+                        wedge ? `Wedge: ${wedge}` : "",
+                        identityConfidence !== null
+                            ? `Identity Confidence: ${Math.round(identityConfidence * 100)}%`
+                            : "",
+                    ]
+                        .filter(Boolean)
+                        .join("\n"),
+                });
+            }
+            else if (audience === "investor") {
+                sections.push({
+                    key: "metrics",
+                    heading: "Key Metrics & Traction",
+                    body: [
+                        companyName ? `Company: ${companyName}` : "",
+                        identityConfidence !== null
+                            ? `Identity Confidence: ${Math.round(identityConfidence * 100)}%`
+                            : "",
+                        `Active Initiatives: ${(content.initiatives ?? []).length}`,
+                        `Open Contradictions: ${contradictions.length}`,
+                        `Pending Actions: ${nextActions.length}`,
+                    ]
+                        .filter(Boolean)
+                        .join("\n"),
+                });
+            }
+            sections.push({
+                key: "summary",
+                heading: audience === "teammate" ? "Context" : "Summary",
+                body: operatingMemo || `${companyName} — ${mission}`,
+            });
+            // What changed
+            if (!config.excludeSections.includes("whatChanged") &&
+                whatChanged.length > 0) {
+                sections.push({
+                    key: "whatChanged",
+                    heading: audience === "developer" ? "Recent Changes" : "What Changed",
+                    items: whatChanged.map((c) => ({
+                        text: c.description ??
+                            c.summary ??
+                            JSON.stringify(c),
+                        meta: c.type ?? undefined,
+                    })),
+                    body: "",
+                });
+            }
+            // Contradictions / risks
+            if (!config.excludeSections.includes("contradictions") &&
+                contradictions.length > 0) {
+                const heading = audience === "investor" || audience === "banker"
+                    ? "Risk Factors"
+                    : "Contradictions & Tensions";
+                sections.push({
+                    key: audience === "investor" || audience === "banker"
+                        ? "riskFactors"
+                        : "contradictions",
+                    heading,
+                    items: contradictions.map((c) => ({
+                        text: c.title ??
+                            c.description ??
+                            JSON.stringify(c),
+                        meta: c.severity ?? undefined,
+                    })),
+                    body: "",
+                });
+            }
+            // Next actions / moves
+            if (nextActions.length > 0) {
+                const heading = audience === "teammate"
+                    ? "Action Items"
+                    : audience === "founder"
+                        ? "Next 3 Moves"
+                        : audience === "developer"
+                            ? "Technical Decisions & Next Steps"
+                            : "Recommended Actions";
+                const items = (audience === "founder" ? nextActions.slice(0, 3) : nextActions).map((a) => ({
+                    text: a.label ?? a.title ?? JSON.stringify(a),
+                    meta: [
+                        a.priority ? `priority: ${a.priority}` : "",
+                        a.owner ? `owner: ${a.owner}` : "",
+                    ]
+                        .filter(Boolean)
+                        .join(", ") || undefined,
+                }));
+                sections.push({
+                    key: audience === "teammate" ? "actionItems" : "nextMoves",
+                    heading,
+                    items,
+                    body: "",
+                });
+            }
+            // Delegation brief (teammate only)
+            if (audience === "teammate") {
+                sections.push({
+                    key: "delegationBrief",
+                    heading: "Delegation Brief",
+                    body: agentInstructions
+                        ? `Focus: ${agentInstructions.focus ?? "See action items"}\nScope: ${agentInstructions.scope ?? "As assigned"}`
+                        : "No specific delegation instructions provided. See action items above.",
+                });
+            }
+            // Market context / comparables
+            if (nearbyEntities.length > 0 &&
+                !config.excludeSections.includes("nearbyEntities")) {
+                const heading = audience === "banker"
+                    ? "Comparables"
+                    : audience === "investor"
+                        ? "Market Context"
+                        : "Nearby Entities";
+                sections.push({
+                    key: audience === "banker" ? "comparables" : "marketContext",
+                    heading,
+                    items: nearbyEntities.map((e) => ({
+                        text: e.name ?? JSON.stringify(e),
+                        meta: e.relationship ?? undefined,
+                    })),
+                    body: "",
+                });
+            }
+            // Financial signals (banker)
+            if (audience === "banker") {
+                const signals = content.financialSignals ?? [];
+                sections.push({
+                    key: "financialSignals",
+                    heading: "Financial Signals",
+                    body: signals.length > 0
+                        ? signals
+                            .map((s) => `${s.label ?? "Signal"}: ${s.value ?? "N/A"}`)
+                            .join("\n")
+                        : "No financial signals available in this packet.",
+                });
+            }
+            // Architecture / API changes (developer)
+            if (audience === "developer") {
+                const archChanges = content.architectureChanges ?? [];
+                const apiChanges = content.apiChanges ?? [];
+                if (archChanges.length > 0 ||
+                    whatChanged.some((c) => (c.type ?? "").includes("arch"))) {
+                    sections.push({
+                        key: "architectureChanges",
+                        heading: "Architecture Changes",
+                        items: archChanges.length > 0
+                            ? archChanges.map((a) => ({
+                                text: a.description ?? JSON.stringify(a),
+                            }))
+                            : [
+                                {
+                                    text: "See recent changes for architecture-related updates.",
+                                },
+                            ],
+                        body: "",
+                    });
+                }
+                if (apiChanges.length > 0) {
+                    sections.push({
+                        key: "apiChanges",
+                        heading: "API Changes",
+                        items: apiChanges.map((a) => ({
+                            text: a.description ?? JSON.stringify(a),
+                        })),
+                        body: "",
+                    });
+                }
+            }
+            // Evidence
+            if (!config.excludeSections.includes("evidence") &&
+                keyEvidence.length > 0) {
+                sections.push({
+                    key: "evidence",
+                    heading: "Key Evidence",
+                    items: keyEvidence.map((e) => ({
+                        text: e.claim ??
+                            e.description ??
+                            JSON.stringify(e),
+                        meta: e.source ?? undefined,
+                    })),
+                    body: "",
+                });
+            }
+            // ── Sort sections by audience config order ──────────────────────
+            const orderMap = new Map(config.sectionOrder.map((key, i) => [key, i]));
+            sections.sort((a, b) => {
+                const aOrder = orderMap.get(a.key) ?? 999;
+                const bOrder = orderMap.get(b.key) ?? 999;
+                return aOrder - bOrder;
+            });
+            // Filter out excluded sections
+            const filteredSections = sections.filter((s) => !config.excludeSections.includes(s.key));
+            // ── Metadata block ──────────────────────────────────────────────
+            const metadataBlock = includeMetadata
+                ? {
+                    generatedAt,
+                    nodebenchVersion: NODEBENCH_VERSION,
+                    exportId,
+                    audience,
+                    format,
+                }
+                : null;
+            // ── Render helpers ──────────────────────────────────────────────
+            function renderSectionMarkdown(s, emphasized) {
+                const marker = emphasized ? " **[KEY]**" : "";
+                let out = `## ${s.heading}${marker}\n\n`;
+                if (s.body)
+                    out += `${s.body}\n\n`;
+                if (s.items) {
+                    for (const item of s.items) {
+                        out += item.meta
+                            ? `- **${item.text}** _(${item.meta})_\n`
+                            : `- ${item.text}\n`;
+                    }
+                    out += "\n";
+                }
+                return out;
+            }
+            function renderSectionPlaintext(s) {
+                let out = `${s.heading.toUpperCase()}\n${"=".repeat(s.heading.length)}\n\n`;
+                if (s.body)
+                    out += `${s.body}\n\n`;
+                if (s.items) {
+                    for (const item of s.items) {
+                        out += item.meta
+                            ? `  - ${item.text} (${item.meta})\n`
+                            : `  - ${item.text}\n`;
+                    }
+                    out += "\n";
+                }
+                return out;
+            }
+            const escapeHtml = (str) => str
+                .replace(/&/g, "&amp;")
+                .replace(/</g, "&lt;")
+                .replace(/>/g, "&gt;")
+                .replace(/"/g, "&quot;");
+            // ── Render by format ────────────────────────────────────────────
+            if (format === "json") {
+                const jsonOutput = {
+                    title: `${config.headerPrefix}${title}`,
+                    audience,
+                    tone: config.tone,
+                    sections: Object.fromEntries(filteredSections.map((s) => [
+                        s.key,
+                        {
+                            heading: s.heading,
+                            ...(s.body ? { body: s.body } : {}),
+                            ...(s.items ? { items: s.items } : {}),
+                            emphasized: config.emphasisSections.includes(s.key),
+                        },
+                    ])),
+                };
+                if (metadataBlock)
+                    jsonOutput._metadata = metadataBlock;
+                return { format: "json", exported: jsonOutput };
+            }
+            if (format === "markdown") {
+                let md = `# ${config.headerPrefix}${title}\n\n`;
+                if (config.tone === "formal")
+                    md += `> Prepared for ${audience} audience\n\n`;
+                md += "---\n\n";
+                for (const s of filteredSections) {
+                    md += renderSectionMarkdown(s, config.emphasisSections.includes(s.key));
+                }
+                if (metadataBlock) {
+                    md += "---\n\n";
+                    md += `_Generated: ${generatedAt} | NodeBench v${NODEBENCH_VERSION} | Export ID: ${exportId}_\n`;
+                }
+                return { format: "markdown", exported: md };
+            }
+            if (format === "plaintext") {
+                let txt = `${config.headerPrefix}${title}\n${"=".repeat((config.headerPrefix + title).length)}\n\n`;
+                for (const s of filteredSections) {
+                    txt += renderSectionPlaintext(s);
+                }
+                if (metadataBlock) {
+                    txt += `${"—".repeat(40)}\n`;
+                    txt += `Generated: ${generatedAt}\nNodeBench v${NODEBENCH_VERSION}\nExport ID: ${exportId}\n`;
+                }
+                return { format: "plaintext", exported: txt };
+            }
+            // HTML format — self-contained with inline CSS matching glass card DNA
+            if (format === "html") {
+                let body = "";
+                for (const s of filteredSections) {
+                    const isKey = config.emphasisSections.includes(s.key);
+                    body += `<section class="card${isKey ? " emphasized" : ""}">\n`;
+                    body += `  <h2>${escapeHtml(s.heading)}${isKey ? ' <span class="badge">KEY</span>' : ""}</h2>\n`;
+                    if (s.body)
+                        body += `  <p>${escapeHtml(s.body).replace(/\n/g, "<br>")}</p>\n`;
+                    if (s.items) {
+                        body += "  <ul>\n";
+                        for (const item of s.items) {
+                            body += item.meta
+                                ? `    <li><strong>${escapeHtml(item.text)}</strong> <span class="meta">(${escapeHtml(item.meta)})</span></li>\n`
+                                : `    <li>${escapeHtml(item.text)}</li>\n`;
+                        }
+                        body += "  </ul>\n";
+                    }
+                    body += "</section>\n";
+                }
+                let metaHtml = "";
+                if (metadataBlock) {
+                    metaHtml = `<footer class="meta-footer">Generated: ${escapeHtml(generatedAt)} &middot; NodeBench v${escapeHtml(NODEBENCH_VERSION)} &middot; Export ID: ${escapeHtml(exportId)}</footer>`;
+                }
+                const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>${escapeHtml(config.headerPrefix + title)}</title>
+<style>
+  @import url('https://fonts.googleapis.com/css2?family=Manrope:wght@400;500;600;700&display=swap');
+  *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+  body {
+    font-family: 'Manrope', system-ui, sans-serif;
+    background: #09090b; color: #fafafa;
+    padding: 2rem; max-width: 800px; margin: 0 auto;
+    line-height: 1.6;
+  }
+  h1 { font-size: 1.5rem; font-weight: 700; margin-bottom: 0.25rem; }
+  .subtitle { color: #a1a1aa; font-size: 0.85rem; margin-bottom: 1.5rem; }
+  .card {
+    background: rgba(255,255,255,0.02);
+    border: 1px solid rgba(255,255,255,0.06);
+    border-radius: 12px; padding: 1.25rem;
+    margin-bottom: 1rem;
+  }
+  .card.emphasized { border-color: #d97757; }
+  .card h2 { font-size: 0.95rem; font-weight: 600; text-transform: uppercase; letter-spacing: 0.12em; margin-bottom: 0.75rem; color: #e4e4e7; }
+  .badge { background: #d97757; color: #09090b; font-size: 0.65rem; padding: 2px 6px; border-radius: 4px; vertical-align: middle; letter-spacing: 0.05em; }
+  .card p { color: #d4d4d8; font-size: 0.9rem; margin-bottom: 0.5rem; }
+  .card ul { list-style: none; padding: 0; }
+  .card li { padding: 0.3rem 0; border-bottom: 1px solid rgba(255,255,255,0.04); font-size: 0.9rem; color: #d4d4d8; }
+  .card li:last-child { border-bottom: none; }
+  .card li strong { color: #fafafa; }
+  .meta { color: #71717a; font-size: 0.8rem; }
+  .meta-footer { margin-top: 2rem; padding-top: 1rem; border-top: 1px solid rgba(255,255,255,0.06); color: #71717a; font-size: 0.75rem; text-align: center; }
+</style>
+</head>
+<body>
+  <h1>${escapeHtml(config.headerPrefix + title)}</h1>
+  <div class="subtitle">Prepared for ${escapeHtml(audience)} audience</div>
+${body}
+${metaHtml}
+</body>
+</html>`;
+                return { format: "html", exported: html };
+            }
+            return { error: true, message: `Unhandled format: ${format}` };
+        },
+    },
 ];
 //# sourceMappingURL=founderTools.js.map