@ouro.bot/cli 0.1.0-alpha.7 → 0.1.0-alpha.70

package/dist/heart/streaming.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FinalAnswerParser = void 0;
+exports.FinalAnswerStreamer = exports.FinalAnswerParser = void 0;
 exports.toResponsesInput = toResponsesInput;
 exports.toResponsesTools = toResponsesTools;
 exports.streamChatCompletion = streamChatCompletion;
@@ -77,6 +77,89 @@ class FinalAnswerParser {
     }
 }
 exports.FinalAnswerParser = FinalAnswerParser;
+// Shared helper: wraps FinalAnswerParser with onClearText + onTextChunk wiring.
+// Used by all streaming providers (Chat Completions, Responses API, Anthropic)
+// so the eager-match streaming pattern lives in one place.
+class FinalAnswerStreamer {
+    parser = new FinalAnswerParser();
+    _detected = false;
+    callbacks;
+    constructor(callbacks) {
+        this.callbacks = callbacks;
+    }
+    get detected() { return this._detected; }
+    get streamed() { return this.parser.active; }
+    /** Mark final_answer as detected. Calls onClearText on the callbacks. */
+    activate() {
+        if (this._detected)
+            return;
+        this._detected = true;
+        this.callbacks.onClearText?.();
+    }
+    /** Feed an argument delta through the parser. Emits text via onTextChunk. */
+    processDelta(delta) {
+        if (!this._detected)
+            return;
+        const text = this.parser.process(delta);
+        if (text)
+            this.callbacks.onTextChunk(text);
+    }
+}
+exports.FinalAnswerStreamer = FinalAnswerStreamer;
+function toResponsesUserContent(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    const parts = [];
+    for (const part of content) {
+        if (!part || typeof part !== "object") {
+            continue;
+        }
+        if (part.type === "text" && typeof part.text === "string") {
+            parts.push({ type: "input_text", text: part.text });
+            continue;
+        }
+        if (part.type === "image_url") {
+            const imageUrl = typeof part.image_url?.url === "string" ? part.image_url.url : "";
+            if (!imageUrl)
+                continue;
+            parts.push({
+                type: "input_image",
+                image_url: imageUrl,
+                detail: part.image_url?.detail ?? "auto",
+            });
+            continue;
+        }
+        if (part.type === "input_audio" &&
+            typeof part.input_audio?.data === "string" &&
+            (part.input_audio.format === "mp3" || part.input_audio.format === "wav")) {
+            parts.push({
+                type: "input_audio",
+                input_audio: {
+                    data: part.input_audio.data,
+                    format: part.input_audio.format,
+                },
+            });
+            continue;
+        }
+        if (part.type === "file") {
+            const fileRecord = { type: "input_file" };
+            if (typeof part.file?.file_data === "string")
+                fileRecord.file_data = part.file.file_data;
+            if (typeof part.file?.file_id === "string")
+                fileRecord.file_id = part.file.file_id;
+            if (typeof part.file?.filename === "string")
+                fileRecord.filename = part.file.filename;
+            if (typeof part.file?.file_data === "string" || typeof part.file?.file_id === "string") {
+                parts.push(fileRecord);
+            }
+        }
+    }
+    return parts.length > 0 ? parts : "";
+}
 function toResponsesInput(messages) {
     let instructions = "";
     const input = [];
@@ -90,7 +173,7 @@ function toResponsesInput(messages) {
         }
         if (msg.role === "user") {
             const u = msg;
-            input.push({ role: "user", content: typeof u.content === "string" ? u.content : "" });
+            input.push({ role: "user", content: toResponsesUserContent(u.content) });
             continue;
         }
         if (msg.role === "assistant") {
@@ -102,7 +185,10 @@ function toResponsesInput(messages) {
                 }
             }
             if (a.content) {
-                input.push({ role: "assistant", content: typeof a.content === "string" ? a.content : "" });
+                const assistantItem = { role: "assistant", content: typeof a.content === "string" ? a.content : "" };
+                if (a.phase)
+                    assistantItem.phase = a.phase;
+                input.push(assistantItem);
             }
             if (a.tool_calls) {
                 for (const tc of a.tool_calls) {
@@ -155,8 +241,7 @@ async function streamChatCompletion(client, createParams, callbacks, signal) {
     let toolCalls = {};
     let streamStarted = false;
     let usage;
-    const answerParser = new FinalAnswerParser();
-    let finalAnswerDetected = false;
+    const answerStreamer = new FinalAnswerStreamer(callbacks);
     // State machine for parsing inline <think> tags (MiniMax pattern)
     let contentBuf = "";
     let inThinkTag = false;
@@ -274,21 +359,18 @@ async function streamChatCompletion(client, createParams, callbacks, signal) {
                     // Detect final_answer tool call on first name delta.
                     // Only activate streaming if this is the sole tool call (index 0
                     // and no other indices seen). Mixed calls are rejected by core.ts.
-                    if (tc.function.name === "final_answer" && !finalAnswerDetected
+                    if (tc.function.name === "final_answer" && !answerStreamer.detected
                         && tc.index === 0 && Object.keys(toolCalls).length === 1) {
-                        finalAnswerDetected = true;
-                        callbacks.onClearText?.();
+                        answerStreamer.activate();
                     }
                 }
                 if (tc.function?.arguments) {
                     toolCalls[tc.index].arguments += tc.function.arguments;
                     // Feed final_answer argument deltas to the parser for progressive
                     // streaming, but only when it appears to be the sole tool call.
-                    if (finalAnswerDetected && toolCalls[tc.index].name === "final_answer"
+                    if (answerStreamer.detected && toolCalls[tc.index].name === "final_answer"
                         && Object.keys(toolCalls).length === 1) {
-                        const text = answerParser.process(tc.function.arguments);
-                        if (text)
-                            callbacks.onTextChunk(text);
+                        answerStreamer.processDelta(tc.function.arguments);
                     }
                 }
             }
@@ -302,7 +384,7 @@ async function streamChatCompletion(client, createParams, callbacks, signal) {
         toolCalls: Object.values(toolCalls),
         outputItems: [],
         usage,
-        finalAnswerStreamed: answerParser.active,
+        finalAnswerStreamed: answerStreamer.streamed,
     };
 }
 async function streamResponsesApi(client, createParams, callbacks, signal) {
@@ -320,9 +402,8 @@ async function streamResponsesApi(client, createParams, callbacks, signal) {
     const outputItems = [];
     let currentToolCall = null;
     let usage;
-    const answerParser = new FinalAnswerParser();
+    const answerStreamer = new FinalAnswerStreamer(callbacks);
     let functionCallCount = 0;
-    let finalAnswerDetected = false;
     for await (const event of response) {
         if (signal?.aborted)
             break;
@@ -355,8 +436,7 @@ async function streamResponsesApi(client, createParams, callbacks, signal) {
                     // Only activate when this is the first (and so far only) function call.
                     // Mixed calls are rejected by core.ts; no need to stream their args.
                     if (String(event.item.name) === "final_answer" && functionCallCount === 1) {
-                        finalAnswerDetected = true;
-                        callbacks.onClearText?.();
+                        answerStreamer.activate();
                     }
                 }
                 break;
@@ -366,11 +446,9 @@ async function streamResponsesApi(client, createParams, callbacks, signal) {
                     currentToolCall.arguments += event.delta;
                     // Feed final_answer argument deltas to the parser for progressive
                     // streaming, but only when it appears to be the sole function call.
-                    if (finalAnswerDetected && currentToolCall.name === "final_answer"
+                    if (answerStreamer.detected && currentToolCall.name === "final_answer"
                         && functionCallCount === 1) {
-                        const text = answerParser.process(String(event.delta));
-                        if (text)
-                            callbacks.onTextChunk(text);
+                        answerStreamer.processDelta(String(event.delta));
                     }
                 }
                 break;
@@ -410,6 +488,6 @@ async function streamResponsesApi(client, createParams, callbacks, signal) {
         toolCalls,
         outputItems,
         usage,
-        finalAnswerStreamed: answerParser.active,
+        finalAnswerStreamed: answerStreamer.streamed,
     };
 }

package/dist/heart/target-resolution.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listTargetSessionCandidates = listTargetSessionCandidates;
+exports.formatTargetSessionCandidates = formatTargetSessionCandidates;
+const session_recall_1 = require("./session-recall");
+const session_activity_1 = require("./session-activity");
+const trust_explanation_1 = require("../mind/friends/trust-explanation");
+const runtime_1 = require("../nerves/runtime");
+function synthesizeFriendRecord(candidate) {
+    return {
+        id: candidate.friendId,
+        name: candidate.friendName,
+        role: "stranger",
+        trustLevel: "stranger",
+        connections: [],
+        externalIds: [],
+        tenantMemberships: [],
+        toolPreferences: {},
+        notes: {},
+        totalTokens: 0,
+        createdAt: new Date(0).toISOString(),
+        updatedAt: new Date(0).toISOString(),
+        schemaVersion: 1,
+    };
+}
+function deliveryPriority(mode) {
+    if (mode === "deliver_now")
+        return 0;
+    if (mode === "queue_only")
+        return 1;
+    return 2;
+}
+function activityPriority(source) {
+    return source === "friend-facing" ? 0 : 1;
+}
+function describeDelivery(candidate) {
+    if (candidate.channel !== "bluebubbles" && candidate.channel !== "teams") {
+        return { mode: "blocked", reason: "this channel does not support proactive outward delivery yet" };
+    }
+    if (candidate.trust.level === "family" || candidate.trust.level === "friend") {
+        return { mode: "deliver_now", reason: "directly trusted target on a proactive-delivery channel" };
+    }
+    return { mode: "queue_only", reason: "visible as a live chat, but immediate delivery still needs explicit cross-chat authorization" };
+}
+async function listTargetSessionCandidates(input) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.target_resolution_start",
+        message: "listing live target session candidates",
+        meta: {
+            sessionsDir: input.sessionsDir,
+            currentSession: input.currentSession
+                ? `${input.currentSession.friendId}/${input.currentSession.channel}/${input.currentSession.key}`
+                : null,
+        },
+    });
+    const activity = (0, session_activity_1.listSessionActivity)({
+        sessionsDir: input.sessionsDir,
+        friendsDir: input.friendsDir,
+        agentName: input.agentName,
+        currentSession: input.currentSession ?? null,
+    }).filter((entry) => entry.channel !== "inner");
+    const candidates = [];
+    for (const entry of activity) {
+        const friend = await input.friendStore.get(entry.friendId) ?? synthesizeFriendRecord(entry);
+        const trust = (0, trust_explanation_1.describeTrustContext)({
+            friend,
+            channel: entry.channel,
+        });
+        const recall = await (0, session_recall_1.recallSession)({
+            sessionPath: entry.sessionPath,
+            friendId: entry.friendId,
+            channel: entry.channel,
+            key: entry.key,
+            messageCount: 6,
+            summarize: input.summarize,
+            trustLevel: trust.level,
+        });
+        const snapshot = recall.kind === "ok"
+            ? recall.snapshot
+            : recall.kind === "empty"
+                ? "recent focus: no recent visible messages"
+                : "recent focus: session transcript unavailable";
+        const delivery = describeDelivery({
+            channel: entry.channel,
+            trust,
+        });
+        candidates.push({
+            friendId: entry.friendId,
+            friendName: entry.friendName,
+            channel: entry.channel,
+            key: entry.key,
+            sessionPath: entry.sessionPath,
+            snapshot,
+            trust,
+            delivery,
+            lastActivityAt: entry.lastActivityAt,
+            lastActivityMs: entry.lastActivityMs,
+            activitySource: entry.activitySource,
+        });
+    }
+    return candidates.sort((a, b) => {
+        const deliveryDiff = deliveryPriority(a.delivery.mode) - deliveryPriority(b.delivery.mode);
+        if (deliveryDiff !== 0)
+            return deliveryDiff;
+        const sourceDiff = activityPriority(a.activitySource) - activityPriority(b.activitySource);
+        if (sourceDiff !== 0)
+            return sourceDiff;
+        return b.lastActivityMs - a.lastActivityMs;
+    });
+}
+function formatTargetSessionCandidates(candidates) {
+    if (candidates.length === 0)
+        return "";
+    const lines = ["## candidate target chats"];
+    for (const candidate of candidates) {
+        lines.push(`- ${candidate.friendName} [${candidate.friendId}] via ${candidate.channel}/${candidate.key}`);
+        lines.push(`  trust: ${candidate.trust.level} (${candidate.trust.basis}) — ${candidate.trust.summary}`);
+        lines.push(`  delivery: ${candidate.delivery.mode} — ${candidate.delivery.reason}`);
+        lines.push(`  snapshot: ${candidate.snapshot}`);
+    }
+    return lines.join("\n");
+}

package/dist/heart/turn-coordinator.js

@@ -1,7 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTurnCoordinator = createTurnCoordinator;
+exports.withSharedTurnLock = withSharedTurnLock;
+exports.tryBeginSharedTurn = tryBeginSharedTurn;
+exports.endSharedTurn = endSharedTurn;
+exports.isSharedTurnActive = isSharedTurnActive;
+exports.enqueueSharedFollowUp = enqueueSharedFollowUp;
+exports.drainSharedFollowUps = drainSharedFollowUps;
 const runtime_1 = require("../nerves/runtime");
+function scopedKey(scope, key) {
+    return `${scope}:${key}`;
+}
 function createTurnCoordinator() {
     const turnLocks = new Map();
     const activeTurns = new Set();
@@ -60,3 +69,22 @@ function createTurnCoordinator() {
         },
     };
 }
+const _sharedTurnCoordinator = createTurnCoordinator();
+function withSharedTurnLock(scope, key, fn) {
+    return _sharedTurnCoordinator.withTurnLock(scopedKey(scope, key), fn);
+}
+function tryBeginSharedTurn(scope, key) {
+    return _sharedTurnCoordinator.tryBeginTurn(scopedKey(scope, key));
+}
+function endSharedTurn(scope, key) {
+    _sharedTurnCoordinator.endTurn(scopedKey(scope, key));
+}
+function isSharedTurnActive(scope, key) {
+    return _sharedTurnCoordinator.isTurnActive(scopedKey(scope, key));
+}
+function enqueueSharedFollowUp(scope, key, followUp) {
+    _sharedTurnCoordinator.enqueueFollowUp(scopedKey(scope, key), followUp);
+}
+function drainSharedFollowUps(scope, key) {
+    return _sharedTurnCoordinator.drainFollowUps(scopedKey(scope, key));
+}

package/dist/mind/associative-recall.js

@@ -87,7 +87,19 @@ function readFacts(memoryRoot) {
     const raw = fs.readFileSync(factsPath, "utf8").trim();
     if (!raw)
         return [];
-    return raw.split("\n").map((line) => JSON.parse(line));
+    const facts = [];
+    for (const line of raw.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            facts.push(JSON.parse(trimmed));
+        }
+        catch {
+            // Skip corrupt lines (e.g. partial write from a crash).
+        }
+    }
+    return facts;
 }
 function getLatestUserText(messages) {
     for (let i = messages.length - 1; i >= 0; i--) {
@@ -190,7 +202,7 @@ async function injectAssociativeRecall(messages, options) {
             event: "mind.associative_recall_error",
             message: "associative recall failed",
             meta: {
-                reason: error instanceof Error ? error.message : String(error),
+                reason: error instanceof Error ? error.message : /* v8 ignore start -- defensive: non-Error catch branch @preserve */ String(error) /* v8 ignore stop */,
             },
         });
     }

package/dist/mind/bundle-manifest.js

@@ -34,6 +34,11 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CANONICAL_BUNDLE_MANIFEST = void 0;
+exports.getChangelogPath = getChangelogPath;
+exports.getPackageVersion = getPackageVersion;
+exports.createBundleMeta = createBundleMeta;
+exports.backfillBundleMeta = backfillBundleMeta;
+exports.resetBackfillTracking = resetBackfillTracking;
 exports.isCanonicalBundlePath = isCanonicalBundlePath;
 exports.findNonCanonicalBundlePaths = findNonCanonicalBundlePaths;
 const fs = __importStar(require("fs"));
@@ -41,6 +46,7 @@ const path = __importStar(require("path"));
 const runtime_1 = require("../nerves/runtime");
 exports.CANONICAL_BUNDLE_MANIFEST = [
     { path: "agent.json", kind: "file" },
+    { path: "bundle-meta.json", kind: "file" },
     { path: "psyche/SOUL.md", kind: "file" },
     { path: "psyche/IDENTITY.md", kind: "file" },
     { path: "psyche/LORE.md", kind: "file" },
@@ -48,11 +54,75 @@ exports.CANONICAL_BUNDLE_MANIFEST = [
     { path: "psyche/ASPIRATIONS.md", kind: "file" },
     { path: "psyche/memory", kind: "dir" },
     { path: "friends", kind: "dir" },
+    { path: "state", kind: "dir" },
     { path: "tasks", kind: "dir" },
     { path: "skills", kind: "dir" },
     { path: "senses", kind: "dir" },
     { path: "senses/teams", kind: "dir" },
 ];
+function getChangelogPath() {
+    const changelogPath = path.resolve(__dirname, "../../changelog.json");
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.changelog_path_resolved",
+        message: "resolved changelog path",
+        meta: { path: changelogPath },
+    });
+    return changelogPath;
+}
+function getPackageVersion() {
+    const packageJsonPath = path.resolve(__dirname, "../../package.json");
+    const raw = fs.readFileSync(packageJsonPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.package_version_read",
+        message: "read package version",
+        meta: { version: parsed.version },
+    });
+    return parsed.version;
+}
+function createBundleMeta() {
+    return {
+        runtimeVersion: getPackageVersion(),
+        bundleSchemaVersion: 1,
+        lastUpdated: new Date().toISOString(),
+    };
+}
+const _backfilledRoots = new Set();
+/**
+ * If bundle-meta.json is missing from the agent root, create it with current runtime version.
+ * This backfills existing agent bundles that were created before bundle-meta.json was introduced.
+ * Only attempts once per bundleRoot per process.
+ */
+function backfillBundleMeta(bundleRoot) {
+    if (_backfilledRoots.has(bundleRoot))
+        return;
+    _backfilledRoots.add(bundleRoot);
+    const metaPath = path.join(bundleRoot, "bundle-meta.json");
+    try {
+        if (fs.existsSync(metaPath)) {
+            return;
+        }
+        const meta = createBundleMeta();
+        fs.writeFileSync(metaPath, JSON.stringify(meta, null, 2) + "\n", "utf-8");
+        (0, runtime_1.emitNervesEvent)({
+            component: "mind",
+            event: "mind.bundle_meta_backfill",
+            message: "backfilled missing bundle-meta.json",
+            meta: { bundleRoot },
+        });
+    }
+    catch {
+        // Non-blocking: if we can't write, that's okay
+    }
+}
+/**
+ * Reset the backfill tracking set. Used in tests.
+ */
+function resetBackfillTracking() {
+    _backfilledRoots.clear();
+}
 const CANONICAL_FILE_PATHS = new Set(exports.CANONICAL_BUNDLE_MANIFEST
     .filter((entry) => entry.kind === "file")
     .map((entry) => entry.path));

package/dist/mind/context.js

@@ -50,17 +50,17 @@ function buildTrimmableBlocks(messages) {
     let i = 0;
     while (i < messages.length) {
         const msg = messages[i];
-        if (msg?.role === "system") {
+        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) {
+        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")
+                if (next.role !== "tool")
                     break;
                 indices.push(i);
                 i++;
@@ -78,13 +78,13 @@ function buildTrimmableBlocks(messages) {
 function getSystemMessageIndices(messages) {
     const indices = [];
     for (let i = 0; i < messages.length; i++) {
-        if (messages[i]?.role === "system")
+        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));
+    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));
@@ -132,7 +132,7 @@ function trimMessages(messages, maxTokens, contextMargin, actualTokenCount) {
     let remaining = actualTokenCount;
     const kept = new Set();
     for (let i = 0; i < messages.length; i++) {
-        if (messages[i]?.role !== "system")
+        if (messages[i].role !== "system")
             kept.add(i);
     }
     // Drop oldest blocks until we fall under target.
@@ -146,7 +146,7 @@ function trimMessages(messages, maxTokens, contextMargin, actualTokenCount) {
     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");
+        trimmed = messages.filter((m) => m.role === "system");
     }
     const estimatedAfter = (0, token_estimate_1.estimateTokensForMessages)(trimmed);
     (0, runtime_1.emitNervesEvent)({
@@ -227,7 +227,7 @@ function repairSessionMessages(messages) {
     });
     return result;
 }
-function saveSession(filePath, messages, lastUsage) {
+function saveSession(filePath, messages, lastUsage, state) {
     const violations = validateSessionMessages(messages);
     if (violations.length > 0) {
         (0, runtime_1.emitNervesEvent)({
@@ -243,6 +243,12 @@ function saveSession(filePath, messages, lastUsage) {
     const envelope = { version: 1, messages };
     if (lastUsage)
         envelope.lastUsage = lastUsage;
+    if (state?.mustResolveBeforeHandoff === true || typeof state?.lastFriendActivityAt === "string") {
+        envelope.state = {
+            ...(state?.mustResolveBeforeHandoff === true ? { mustResolveBeforeHandoff: true } : {}),
+            ...(typeof state?.lastFriendActivityAt === "string" ? { lastFriendActivityAt: state.lastFriendActivityAt } : {}),
+        };
+    }
     fs.writeFileSync(filePath, JSON.stringify(envelope, null, 2));
 }
 function loadSession(filePath) {
@@ -263,13 +269,23 @@ function loadSession(filePath) {
             });
             messages = repairSessionMessages(messages);
         }
-        return { messages, lastUsage: data.lastUsage };
+        const rawState = data?.state && typeof data.state === "object" && data.state !== null
+            ? data.state
+            : undefined;
+        const state = rawState && (rawState.mustResolveBeforeHandoff === true
+            || typeof rawState.lastFriendActivityAt === "string")
+            ? {
+                ...(rawState.mustResolveBeforeHandoff === true ? { mustResolveBeforeHandoff: true } : {}),
+                ...(typeof rawState.lastFriendActivityAt === "string" ? { lastFriendActivityAt: rawState.lastFriendActivityAt } : {}),
+            }
+            : undefined;
+        return { messages, lastUsage: data.lastUsage, state };
     }
     catch {
         return null;
     }
 }
-function postTurn(messages, sessPath, usage, hooks) {
+function postTurn(messages, sessPath, usage, hooks, state) {
     if (hooks?.beforeTrim) {
         try {
             hooks.beforeTrim([...messages]);
@@ -289,7 +305,7 @@ function postTurn(messages, sessPath, usage, hooks) {
     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);
+    saveSession(sessPath, messages, usage, state);
 }
 function deleteSession(filePath) {
     try {

package/dist/mind/first-impressions.js

@@ -11,9 +11,22 @@ exports.ONBOARDING_TOKEN_THRESHOLD = 100_000;
 function isOnboarding(friend) {
     return (friend.totalTokens ?? 0) < exports.ONBOARDING_TOKEN_THRESHOLD;
 }
-function getFirstImpressions(friend) {
+function hasLiveContinuityPressure(state) {
+    if (!state)
+        return false;
+    if (typeof state.currentObligation === "string" && state.currentObligation.trim().length > 0)
+        return true;
+    if (state.mustResolveBeforeHandoff === true)
+        return true;
+    if (state.hasQueuedFollowUp === true)
+        return true;
+    return false;
+}
+function getFirstImpressions(friend, state) {
     if (!isOnboarding(friend))
         return "";
+    if (hasLiveContinuityPressure(state))
+        return "";
     (0, runtime_1.emitNervesEvent)({
         component: "mind",
         event: "mind.first_impressions",
@@ -37,7 +50,8 @@ function getFirstImpressions(friend) {
     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("if we're already in motion on a task, thread, or follow-up, i do not reset with a generic opener like 'hiya' or 'what do ya need help with?'. i continue directly or ask the specific next question.");
+    lines.push("only when the conversation is genuinely fresh and idle, with no active ask or thread in flight, a light opener is okay.");
     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");
 }