@ouro.bot/cli 0.0.1-alpha.0 → 0.1.0-alpha.2

package/dist/mind/associative-recall.js

@@ -0,0 +1,197 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cosineSimilarity = cosineSimilarity;
+exports.recallFactsForQuery = recallFactsForQuery;
+exports.injectAssociativeRecall = injectAssociativeRecall;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("../heart/config");
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+const DEFAULT_EMBEDDING_MODEL = "text-embedding-3-small";
+const DEFAULT_MIN_SCORE = 0.5;
+const DEFAULT_TOP_K = 3;
+class OpenAIEmbeddingProvider {
+    apiKey;
+    model;
+    constructor(apiKey, model = DEFAULT_EMBEDDING_MODEL) {
+        this.apiKey = apiKey;
+        this.model = model;
+    }
+    async embed(texts) {
+        const response = await fetch("https://api.openai.com/v1/embeddings", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                model: this.model,
+                input: texts,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`embedding request failed: ${response.status} ${response.statusText}`);
+        }
+        const payload = (await response.json());
+        if (!payload.data || payload.data.length !== texts.length) {
+            throw new Error("embedding response missing expected vectors");
+        }
+        return payload.data.map((entry) => entry.embedding);
+    }
+}
+function createDefaultProvider() {
+    const apiKey = (0, config_1.getOpenAIEmbeddingsApiKey)();
+    if (!apiKey) {
+        throw new Error("openaiEmbeddingsApiKey not configured");
+    }
+    return new OpenAIEmbeddingProvider(apiKey);
+}
+function readFacts(memoryRoot) {
+    const factsPath = path.join(memoryRoot, "facts.jsonl");
+    if (!fs.existsSync(factsPath))
+        return [];
+    const raw = fs.readFileSync(factsPath, "utf8").trim();
+    if (!raw)
+        return [];
+    return raw.split("\n").map((line) => JSON.parse(line));
+}
+function getLatestUserText(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        if (message.role !== "user")
+            continue;
+        if (typeof message.content !== "string")
+            continue;
+        const text = message.content.trim();
+        if (text.length > 0)
+            return text;
+    }
+    return "";
+}
+function cosineSimilarity(left, right) {
+    if (left.length === 0 || right.length === 0 || left.length !== right.length)
+        return 0;
+    let dot = 0;
+    let leftNorm = 0;
+    let rightNorm = 0;
+    for (let i = 0; i < left.length; i++) {
+        dot += left[i] * right[i];
+        leftNorm += left[i] * left[i];
+        rightNorm += right[i] * right[i];
+    }
+    if (leftNorm === 0 || rightNorm === 0)
+        return 0;
+    return dot / (Math.sqrt(leftNorm) * Math.sqrt(rightNorm));
+}
+async function recallFactsForQuery(query, facts, provider, options) {
+    const trimmed = query.trim();
+    if (!trimmed)
+        return [];
+    const minScore = options?.minScore ?? DEFAULT_MIN_SCORE;
+    const topK = options?.topK ?? DEFAULT_TOP_K;
+    const [queryEmbedding] = await provider.embed([trimmed]);
+    return facts
+        .map((fact) => ({
+        ...fact,
+        score: cosineSimilarity(queryEmbedding, fact.embedding),
+    }))
+        .filter((fact) => fact.score >= minScore)
+        .sort((left, right) => right.score - left.score)
+        .slice(0, topK);
+}
+async function injectAssociativeRecall(messages, options) {
+    try {
+        if (messages[0]?.role !== "system" || typeof messages[0].content !== "string")
+            return;
+        const query = getLatestUserText(messages);
+        if (!query)
+            return;
+        const memoryRoot = options?.memoryRoot ?? path.join((0, identity_1.getAgentRoot)(), "psyche", "memory");
+        const facts = readFacts(memoryRoot);
+        if (facts.length === 0)
+            return;
+        let recalled;
+        try {
+            const provider = options?.provider ?? createDefaultProvider();
+            recalled = await recallFactsForQuery(query, facts, provider, options);
+        }
+        catch {
+            // Embeddings unavailable — fall back to substring matching
+            const lowerQuery = query.toLowerCase();
+            const topK = options?.topK ?? DEFAULT_TOP_K;
+            recalled = facts
+                .filter((fact) => fact.text.toLowerCase().includes(lowerQuery))
+                .slice(0, topK)
+                .map((fact) => ({ ...fact, score: 1 }));
+            if (recalled.length > 0) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "mind",
+                    event: "mind.associative_recall_fallback",
+                    message: "embeddings unavailable, used substring fallback",
+                    meta: { matchCount: recalled.length },
+                });
+            }
+        }
+        if (recalled.length === 0)
+            return;
+        const recallSection = recalled
+            .map((fact, index) => `${index + 1}. ${fact.text} [score=${fact.score.toFixed(3)} source=${fact.source}]`)
+            .join("\n");
+        messages[0] = {
+            role: "system",
+            content: `${messages[0].content}\n\n## recalled context\n${recallSection}`,
+        };
+        (0, runtime_1.emitNervesEvent)({
+            component: "mind",
+            event: "mind.associative_recall",
+            message: "associative recall injected",
+            meta: { count: recalled.length },
+        });
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "mind",
+            event: "mind.associative_recall_error",
+            message: "associative recall failed",
+            meta: {
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+    }
+}

package/dist/mind/bundle-manifest.js

@@ -0,0 +1,118 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CANONICAL_BUNDLE_MANIFEST = void 0;
+exports.isCanonicalBundlePath = isCanonicalBundlePath;
+exports.findNonCanonicalBundlePaths = findNonCanonicalBundlePaths;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+exports.CANONICAL_BUNDLE_MANIFEST = [
+    { path: "agent.json", kind: "file" },
+    { path: "psyche/SOUL.md", kind: "file" },
+    { path: "psyche/IDENTITY.md", kind: "file" },
+    { path: "psyche/LORE.md", kind: "file" },
+    { path: "psyche/TACIT.md", kind: "file" },
+    { path: "psyche/ASPIRATIONS.md", kind: "file" },
+    { path: "psyche/memory", kind: "dir" },
+    { path: "friends", kind: "dir" },
+    { path: "tasks", kind: "dir" },
+    { path: "skills", kind: "dir" },
+    { path: "senses", kind: "dir" },
+    { path: "senses/teams", kind: "dir" },
+];
+const CANONICAL_FILE_PATHS = new Set(exports.CANONICAL_BUNDLE_MANIFEST
+    .filter((entry) => entry.kind === "file")
+    .map((entry) => entry.path));
+const CANONICAL_DIR_PATHS = exports.CANONICAL_BUNDLE_MANIFEST
+    .filter((entry) => entry.kind === "dir")
+    .map((entry) => entry.path);
+function normalizeRelativePath(relativePath) {
+    return relativePath
+        .replace(/\\/g, "/")
+        .replace(/^\.?\/+/, "")
+        .replace(/\/+$/, "");
+}
+function isCanonicalBundlePath(relativePath) {
+    const normalized = normalizeRelativePath(relativePath);
+    if (!normalized)
+        return true;
+    if (CANONICAL_FILE_PATHS.has(normalized))
+        return true;
+    return CANONICAL_DIR_PATHS.some((canonicalDir) => normalized === canonicalDir || normalized.startsWith(`${canonicalDir}/`));
+}
+function findNonCanonicalBundlePaths(bundleRoot) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.bundle_manifest_scan_start",
+        message: "scanning bundle for non-canonical paths",
+        meta: { bundle_root: bundleRoot },
+    });
+    const discovered = listBundleRelativePaths(bundleRoot);
+    const nonCanonical = discovered
+        .filter((relativePath) => !isCanonicalBundlePath(relativePath))
+        .sort((left, right) => left.localeCompare(right));
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.bundle_manifest_scan_end",
+        message: "bundle non-canonical scan complete",
+        meta: { bundle_root: bundleRoot, non_canonical_count: nonCanonical.length },
+    });
+    return nonCanonical;
+}
+function listBundleRelativePaths(bundleRoot) {
+    const discovered = [];
+    function walk(currentAbsolutePath, currentRelativePath) {
+        let entries;
+        try {
+            entries = fs.readdirSync(currentAbsolutePath, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const absolutePath = path.join(currentAbsolutePath, entry.name);
+            const relativePath = currentRelativePath
+                ? `${currentRelativePath}/${entry.name}`
+                : entry.name;
+            discovered.push(relativePath);
+            if (entry.isDirectory()) {
+                walk(absolutePath, relativePath);
+            }
+        }
+    }
+    walk(bundleRoot, "");
+    return discovered;
+}

package/dist/mind/context.js

@@ -0,0 +1,302 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trimMessages = trimMessages;
+exports.validateSessionMessages = validateSessionMessages;
+exports.repairSessionMessages = repairSessionMessages;
+exports.saveSession = saveSession;
+exports.loadSession = loadSession;
+exports.postTurn = postTurn;
+exports.deleteSession = deleteSession;
+const config_1 = require("../heart/config");
+const runtime_1 = require("../nerves/runtime");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const token_estimate_1 = require("./token-estimate");
+function buildTrimmableBlocks(messages) {
+    const blocks = [];
+    let i = 0;
+    while (i < messages.length) {
+        const msg = messages[i];
+        if (msg?.role === "system") {
+            i++;
+            continue;
+        }
+        // Tool coherence block: assistant message with tool_calls + immediately following tool results
+        if (msg?.role === "assistant" && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0) {
+            const indices = [i];
+            i++;
+            while (i < messages.length) {
+                const next = messages[i];
+                if (next?.role !== "tool")
+                    break;
+                indices.push(i);
+                i++;
+            }
+            const blockMsgs = indices.map((idx) => messages[idx]);
+            blocks.push({ indices, estimatedTokens: (0, token_estimate_1.estimateTokensForMessages)(blockMsgs) });
+            continue;
+        }
+        // Default: one message per block
+        blocks.push({ indices: [i], estimatedTokens: (0, token_estimate_1.estimateTokensForMessages)([messages[i]]) });
+        i++;
+    }
+    return blocks;
+}
+function getSystemMessageIndices(messages) {
+    const indices = [];
+    for (let i = 0; i < messages.length; i++) {
+        if (messages[i]?.role === "system")
+            indices.push(i);
+    }
+    return indices;
+}
+function buildTrimmedMessages(messages, kept) {
+    return messages.filter((m, idx) => m?.role === "system" || kept.has(idx));
+}
+function trimMessages(messages, maxTokens, contextMargin, actualTokenCount) {
+    const targetTokens = Math.floor(maxTokens * (1 - contextMargin / 100));
+    const estimatedBefore = (0, token_estimate_1.estimateTokensForMessages)(messages);
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.step_start",
+        component: "mind",
+        message: "trimMessages started",
+        meta: {
+            maxTokens,
+            contextMargin,
+            targetTokens,
+            messageCount: messages.length,
+            actualTokenCount: actualTokenCount ?? null,
+            estimated_before: estimatedBefore,
+        },
+    });
+    const coldStart = actualTokenCount == null || actualTokenCount === 0;
+    const overTokens = actualTokenCount != null && actualTokenCount > maxTokens;
+    // We only trim when the provider reported that we overflowed the model context.
+    // If actualTokenCount is missing/0, we treat it as a cold start and do not trim.
+    if (coldStart || !overTokens) {
+        (0, runtime_1.emitNervesEvent)({
+            event: "mind.step_end",
+            component: "mind",
+            message: "trimMessages completed without trimming",
+            meta: {
+                trimmed: false,
+                messageCount: messages.length,
+                targetTokens,
+                actualTokenCount: actualTokenCount ?? null,
+                estimated_before: estimatedBefore,
+                estimated_after: estimatedBefore,
+            },
+        });
+        return [...messages];
+    }
+    const systemIndices = getSystemMessageIndices(messages);
+    const systemMsgs = systemIndices.map((i) => messages[i]);
+    const estimatedSystem = (0, token_estimate_1.estimateTokensForMessages)(systemMsgs);
+    const blocks = buildTrimmableBlocks(messages);
+    // Approximate token contribution uniformly across messages, per contract tests.
+    // Note: this is intentionally simple and does not attempt token-accurate attribution.
+    const perMessageCost = actualTokenCount / Math.max(1, messages.length);
+    let remaining = actualTokenCount;
+    const kept = new Set();
+    for (let i = 0; i < messages.length; i++) {
+        if (messages[i]?.role !== "system")
+            kept.add(i);
+    }
+    // Drop oldest blocks until we fall under target.
+    for (let b = 0; b < blocks.length && remaining > targetTokens; b++) {
+        const block = blocks[b];
+        for (const idx of block.indices) {
+            kept.delete(idx);
+            remaining -= perMessageCost;
+        }
+    }
+    let trimmed = buildTrimmedMessages(messages, kept);
+    // If we're still above budget after dropping everything trimmable, preserve system only.
+    if (remaining > targetTokens) {
+        trimmed = messages.filter((m) => m?.role === "system");
+    }
+    const estimatedAfter = (0, token_estimate_1.estimateTokensForMessages)(trimmed);
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.step_end",
+        component: "mind",
+        message: "trimMessages completed with trimming",
+        meta: {
+            trimmed: true,
+            originalCount: messages.length,
+            finalCount: trimmed.length,
+            targetTokens,
+            actualTokenCount,
+            estimated_before: estimatedBefore,
+            estimated_after: estimatedAfter,
+            estimated_system: estimatedSystem,
+            blockCount: blocks.length,
+            forcedDrop: true,
+        },
+    });
+    return trimmed;
+}
+/**
+ * Checks session invariant: after system messages, sequence must be
+ * user → assistant (with optional tool calls/results) → user → assistant...
+ * Never assistant → assistant without a user in between.
+ */
+function validateSessionMessages(messages) {
+    const violations = [];
+    let prevNonToolRole = null;
+    let prevAssistantHadToolCalls = false;
+    let sawToolResultSincePrevAssistant = false;
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        if (msg.role === "system")
+            continue;
+        if (msg.role === "tool") {
+            sawToolResultSincePrevAssistant = true;
+            continue;
+        }
+        if (msg.role === "assistant" && prevNonToolRole === "assistant") {
+            // assistant → tool(s) → assistant is valid (tool call flow)
+            if (!(prevAssistantHadToolCalls && sawToolResultSincePrevAssistant)) {
+                violations.push(`back-to-back assistant at index ${i}`);
+            }
+        }
+        prevAssistantHadToolCalls = msg.role === "assistant" && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0;
+        sawToolResultSincePrevAssistant = false;
+        prevNonToolRole = msg.role;
+    }
+    return violations;
+}
+/**
+ * Repairs session invariant violations by merging consecutive assistant messages.
+ */
+function repairSessionMessages(messages) {
+    const violations = validateSessionMessages(messages);
+    if (violations.length === 0)
+        return messages;
+    const result = [];
+    for (const msg of messages) {
+        if (msg.role === "assistant" && result.length > 0) {
+            const prev = result[result.length - 1];
+            if (prev.role === "assistant" && !("tool_calls" in prev)) {
+                const prevContent = typeof prev.content === "string" ? prev.content : "";
+                const curContent = typeof msg.content === "string" ? msg.content : "";
+                prev.content = `${prevContent}\n\n${curContent}`;
+                continue;
+            }
+        }
+        result.push(msg);
+    }
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        event: "mind.session_invariant_repair",
+        component: "mind",
+        message: "repaired session invariant violations",
+        meta: { violations },
+    });
+    return result;
+}
+function saveSession(filePath, messages, lastUsage) {
+    const violations = validateSessionMessages(messages);
+    if (violations.length > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            event: "mind.session_invariant_violation",
+            component: "mind",
+            message: "session invariant violated on save",
+            meta: { path: filePath, violations },
+        });
+        messages = repairSessionMessages(messages);
+    }
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const envelope = { version: 1, messages };
+    if (lastUsage)
+        envelope.lastUsage = lastUsage;
+    fs.writeFileSync(filePath, JSON.stringify(envelope, null, 2));
+}
+function loadSession(filePath) {
+    try {
+        const raw = fs.readFileSync(filePath, "utf-8");
+        const data = JSON.parse(raw);
+        if (data.version !== 1)
+            return null;
+        let messages = data.messages;
+        const violations = validateSessionMessages(messages);
+        if (violations.length > 0) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                event: "mind.session_invariant_violation",
+                component: "mind",
+                message: "session invariant violated on load",
+                meta: { path: filePath, violations },
+            });
+            messages = repairSessionMessages(messages);
+        }
+        return { messages, lastUsage: data.lastUsage };
+    }
+    catch {
+        return null;
+    }
+}
+function postTurn(messages, sessPath, usage, hooks) {
+    if (hooks?.beforeTrim) {
+        try {
+            hooks.beforeTrim([...messages]);
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                event: "mind.post_turn_hook_error",
+                component: "mind",
+                message: "postTurn beforeTrim hook failed",
+                meta: {
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
+    const { maxTokens, contextMargin } = (0, config_1.getContextConfig)();
+    const trimmed = trimMessages(messages, maxTokens, contextMargin, usage?.input_tokens);
+    messages.splice(0, messages.length, ...trimmed);
+    saveSession(sessPath, messages, usage);
+}
+function deleteSession(filePath) {
+    try {
+        fs.unlinkSync(filePath);
+    }
+    catch (e) {
+        if (e instanceof Error && e.code !== "ENOENT")
+            throw e;
+    }
+}

package/dist/mind/first-impressions.js

@@ -0,0 +1,43 @@
+"use strict";
+// First-impressions module.
+// Onboarding instructions emitted below ONBOARDING_TOKEN_THRESHOLD.
+// These drop from the system prompt once cumulative token usage exceeds the threshold.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ONBOARDING_TOKEN_THRESHOLD = void 0;
+exports.isOnboarding = isOnboarding;
+exports.getFirstImpressions = getFirstImpressions;
+const runtime_1 = require("../nerves/runtime");
+exports.ONBOARDING_TOKEN_THRESHOLD = 100_000;
+function isOnboarding(friend) {
+    return (friend.totalTokens ?? 0) < exports.ONBOARDING_TOKEN_THRESHOLD;
+}
+function getFirstImpressions(friend) {
+    if (!isOnboarding(friend))
+        return "";
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.first_impressions",
+        message: "generating onboarding content",
+        meta: {},
+    });
+    const lines = [];
+    if (friend.name === "Unknown") {
+        lines.push("i don't know this friend's name yet. i ask what they'd like to be called early in our conversation.");
+    }
+    else {
+        lines.push(`this is ${friend.name} -- i'm still getting to know them.`);
+    }
+    lines.push("i actively ask my friend about themselves. things i want to learn early:");
+    lines.push("- what's their role, and what does a typical day look like for them?");
+    lines.push("- what are they working on right now that they're most excited (or stressed) about?");
+    lines.push("- what takes up too much of their time that they wish they could offload?");
+    lines.push("- who do they collaborate with most, and what does that workflow look like?");
+    lines.push("- what tools and systems do they live in day-to-day?");
+    lines.push("- how do they prefer to communicate -- brief and direct, or detailed and exploratory?");
+    lines.push("- what do they do outside of work that they care about?");
+    lines.push("i don't ask all of these at once -- i weave them into conversation naturally, one or two at a time, and i genuinely follow up on what they share.");
+    lines.push("i introduce what i can do -- i have tools, integrations, and skills that can help them. i mention these naturally as they become relevant.");
+    lines.push("if my friend hasn't asked me to do something specific, or i've already finished what they asked for, that's my cue to turn the tables -- i ask them questions about themselves, what they're into, what they need. no idle small talk; i'm on a mission to get to know them.");
+    lines.push("i save everything i learn immediately with save_friend_note -- names, roles, preferences, projects, anything. the bar is low: if i learned it, i save it.");
+    return lines.join("\n");
+}