@ouro.bot/cli 0.1.0-alpha.24 → 0.1.0-alpha.241

package/dist/heart/streaming.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FinalAnswerStreamer = exports.FinalAnswerParser = void 0;
+exports.SettleStreamer = exports.SettleParser = void 0;
 exports.toResponsesInput = toResponsesInput;
 exports.toResponsesTools = toResponsesTools;
 exports.streamChatCompletion = streamChatCompletion;
 exports.streamResponsesApi = streamResponsesApi;
 const runtime_1 = require("../nerves/runtime");
 // Character-level state machine that extracts the answer value from
-// `final_answer` tool call JSON arguments as they stream in.
+// `settle` tool call JSON arguments as they stream in.
 // Scans for prefix `"answer":"` or `"answer": "` in the character stream,
 // then emits text handling JSON escapes, stopping at unescaped closing `"`.
-class FinalAnswerParser {
+class SettleParser {
     // Possible prefixes to match (with and without space after colon)
     static PREFIXES = ['"answer":"', '"answer": "'];
     // Buffer of characters seen so far (pre-activation only)
@@ -29,7 +29,7 @@ class FinalAnswerParser {
             if (!this._active) {
                 this.buf += ch;
                 // Check if any prefix has been fully matched in the buffer
-                for (const prefix of FinalAnswerParser.PREFIXES) {
+                for (const prefix of SettleParser.PREFIXES) {
                     if (this.buf.endsWith(prefix)) {
                         this._active = true;
                         break;
@@ -76,21 +76,25 @@ class FinalAnswerParser {
         return out;
     }
 }
-exports.FinalAnswerParser = FinalAnswerParser;
-// Shared helper: wraps FinalAnswerParser with onClearText + onTextChunk wiring.
+exports.SettleParser = SettleParser;
+// Shared helper: wraps SettleParser 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();
+// so the eager-match settle streaming pattern lives in one place.
+class SettleStreamer {
+    parser = new SettleParser();
     _detected = false;
     callbacks;
-    constructor(callbacks) {
+    enabled;
+    constructor(callbacks, enabled = true) {
         this.callbacks = callbacks;
+        this.enabled = enabled;
     }
     get detected() { return this._detected; }
     get streamed() { return this.parser.active; }
-    /** Mark final_answer as detected. Calls onClearText on the callbacks. */
+    /** Mark settle as detected. Calls onClearText on the callbacks. */
     activate() {
+        if (!this.enabled)
+            return;
         if (this._detected)
             return;
         this._detected = true;
@@ -98,6 +102,8 @@ class FinalAnswerStreamer {
     }
     /** Feed an argument delta through the parser. Emits text via onTextChunk. */
     processDelta(delta) {
+        if (!this.enabled)
+            return;
         if (!this._detected)
             return;
         const text = this.parser.process(delta);
@@ -105,7 +111,7 @@ class FinalAnswerStreamer {
             this.callbacks.onTextChunk(text);
     }
 }
-exports.FinalAnswerStreamer = FinalAnswerStreamer;
+exports.SettleStreamer = SettleStreamer;
 function toResponsesUserContent(content) {
     if (typeof content === "string") {
         return content;
@@ -185,7 +191,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) {
@@ -224,7 +233,7 @@ function toResponsesTools(ccTools) {
         strict: false,
     }));
 }
-async function streamChatCompletion(client, createParams, callbacks, signal) {
+async function streamChatCompletion(client, createParams, callbacks, signal, eagerSettleStreaming = true) {
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
         event: "engine.stream_start",
@@ -238,7 +247,7 @@ async function streamChatCompletion(client, createParams, callbacks, signal) {
     let toolCalls = {};
     let streamStarted = false;
     let usage;
-    const answerStreamer = new FinalAnswerStreamer(callbacks);
+    const answerStreamer = new SettleStreamer(callbacks, eagerSettleStreaming);
     // State machine for parsing inline <think> tags (MiniMax pattern)
     let contentBuf = "";
     let inThinkTag = false;
@@ -353,19 +362,19 @@ async function streamChatCompletion(client, createParams, callbacks, signal) {
                     toolCalls[tc.index].id = tc.id;
                 if (tc.function?.name) {
                     toolCalls[tc.index].name = tc.function.name;
-                    // Detect final_answer tool call on first name delta.
+                    // Detect settle 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" && !answerStreamer.detected
+                    if (tc.function.name === "settle" && !answerStreamer.detected
                         && tc.index === 0 && Object.keys(toolCalls).length === 1) {
                         answerStreamer.activate();
                     }
                 }
                 if (tc.function?.arguments) {
                     toolCalls[tc.index].arguments += tc.function.arguments;
-                    // Feed final_answer argument deltas to the parser for progressive
+                    // Feed settle argument deltas to the parser for progressive
                     // streaming, but only when it appears to be the sole tool call.
-                    if (answerStreamer.detected && toolCalls[tc.index].name === "final_answer"
+                    if (answerStreamer.detected && toolCalls[tc.index].name === "settle"
                         && Object.keys(toolCalls).length === 1) {
                         answerStreamer.processDelta(tc.function.arguments);
                     }
@@ -381,10 +390,10 @@ async function streamChatCompletion(client, createParams, callbacks, signal) {
         toolCalls: Object.values(toolCalls),
         outputItems: [],
         usage,
-        finalAnswerStreamed: answerStreamer.streamed,
+        settleStreamed: answerStreamer.streamed,
     };
 }
-async function streamResponsesApi(client, createParams, callbacks, signal) {
+async function streamResponsesApi(client, createParams, callbacks, signal, eagerSettleStreaming = true) {
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
         event: "engine.stream_start",
@@ -399,7 +408,7 @@ async function streamResponsesApi(client, createParams, callbacks, signal) {
     const outputItems = [];
     let currentToolCall = null;
     let usage;
-    const answerStreamer = new FinalAnswerStreamer(callbacks);
+    const answerStreamer = new SettleStreamer(callbacks, eagerSettleStreaming);
     let functionCallCount = 0;
     for await (const event of response) {
         if (signal?.aborted)
@@ -429,10 +438,10 @@ async function streamResponsesApi(client, createParams, callbacks, signal) {
                         name: String(event.item.name),
                         arguments: "",
                     };
-                    // Detect final_answer function call -- clear any streamed noise.
+                    // Detect settle function call -- clear any streamed noise.
                     // 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) {
+                    if (String(event.item.name) === "settle" && functionCallCount === 1) {
                         answerStreamer.activate();
                     }
                 }
@@ -441,9 +450,9 @@ async function streamResponsesApi(client, createParams, callbacks, signal) {
             case "response.function_call_arguments.delta": {
                 if (currentToolCall) {
                     currentToolCall.arguments += event.delta;
-                    // Feed final_answer argument deltas to the parser for progressive
+                    // Feed settle argument deltas to the parser for progressive
                     // streaming, but only when it appears to be the sole function call.
-                    if (answerStreamer.detected && currentToolCall.name === "final_answer"
+                    if (answerStreamer.detected && currentToolCall.name === "settle"
                         && functionCallCount === 1) {
                         answerStreamer.processDelta(String(event.delta));
                     }
@@ -485,6 +494,6 @@ async function streamResponsesApi(client, createParams, callbacks, signal) {
         toolCalls,
         outputItems,
         usage,
-        finalAnswerStreamed: answerStreamer.streamed,
+        settleStreamed: answerStreamer.streamed,
     };
 }

package/dist/heart/sync.js

@@ -0,0 +1,217 @@
+"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.runWithSyncContext = runWithSyncContext;
+exports.trackSyncWrite = trackSyncWrite;
+exports.drainSyncWrites = drainSyncWrites;
+exports.preTurnPull = preTurnPull;
+exports.postTurnPush = postTurnPush;
+const node_async_hooks_1 = require("node:async_hooks");
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+/**
+ * Turn-scoped write tracker using AsyncLocalStorage.
+ * Each turn runs inside its own async context (via runWithSyncContext),
+ * so concurrent turns from different senses never share or clobber each
+ * other's tracked writes.
+ *
+ * Continuity writers (episodes, obligations, cares, intentions, diary)
+ * call trackSyncWrite() after every fs write. drainSyncWrites() returns
+ * the current turn's accumulated set and clears it.
+ */
+const syncContext = new node_async_hooks_1.AsyncLocalStorage();
+/**
+ * Run a function inside its own sync-write tracking context.
+ * All trackSyncWrite / drainSyncWrites calls within `fn` (including
+ * across awaits) operate on a private Set scoped to this invocation.
+ */
+function runWithSyncContext(fn) {
+    return syncContext.run(new Set(), fn);
+}
+/** Register an absolute file path written during this turn. No-op if called outside a sync context. */
+function trackSyncWrite(absolutePath) {
+    syncContext.getStore()?.add(absolutePath);
+}
+/** Return all paths written this turn and clear the set. Returns [] if called outside a sync context. */
+function drainSyncWrites() {
+    const store = syncContext.getStore();
+    if (!store)
+        return [];
+    const paths = [...store];
+    store.clear();
+    return paths;
+}
+/**
+ * Pre-turn pull: sync the agent bundle from remote before assembling the start-of-turn packet.
+ */
+function preTurnPull(agentRoot, config) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.sync_pull_start",
+        message: "pre-turn pull starting",
+        meta: { agentRoot, remote: config.remote },
+    });
+    try {
+        (0, child_process_1.execFileSync)("git", ["pull", config.remote], {
+            cwd: agentRoot,
+            stdio: "pipe",
+            timeout: 30000,
+        });
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.sync_pull_end",
+            message: "pre-turn pull complete",
+            meta: { agentRoot },
+        });
+        return { ok: true };
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.sync_pull_error",
+            message: "pre-turn pull failed",
+            meta: { agentRoot, error },
+        });
+        return { ok: false, error };
+    }
+}
+/**
+ * Post-turn push: commit and push files written during this turn.
+ * Receives an explicit list of absolute paths (from drainSyncWrites) instead of
+ * discovering changes via git status. Empty list = no changes = skip.
+ */
+function postTurnPush(agentRoot, config, writtenPaths) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.sync_push_start",
+        message: "post-turn push starting",
+        meta: { agentRoot, remote: config.remote },
+    });
+    if (writtenPaths.length === 0) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.sync_push_end",
+            message: "post-turn push: no changes to sync",
+            meta: { agentRoot },
+        });
+        return { ok: true };
+    }
+    // Convert absolute paths to relative (for git add)
+    const relativePaths = writtenPaths
+        .map((p) => path.relative(agentRoot, p))
+        .filter((p) => p.length > 0 && !p.startsWith(".."));
+    if (relativePaths.length === 0) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.sync_push_end",
+            message: "post-turn push: no in-bundle paths to sync",
+            meta: { agentRoot },
+        });
+        return { ok: true };
+    }
+    try {
+        // Stage only the specific files written during this turn
+        (0, child_process_1.execFileSync)("git", ["add", "--", ...relativePaths], {
+            cwd: agentRoot,
+            stdio: "pipe",
+            timeout: 10000,
+        });
+        (0, child_process_1.execFileSync)("git", ["commit", "-m", "sync: post-turn update"], {
+            cwd: agentRoot,
+            stdio: "pipe",
+            timeout: 10000,
+        });
+        try {
+            (0, child_process_1.execFileSync)("git", ["push", config.remote], {
+                cwd: agentRoot,
+                stdio: "pipe",
+                timeout: 30000,
+            });
+        }
+        catch {
+            // Push rejected -- try pull-rebase-push
+            try {
+                (0, child_process_1.execFileSync)("git", ["pull", "--rebase", config.remote], {
+                    cwd: agentRoot,
+                    stdio: "pipe",
+                    timeout: 30000,
+                });
+                (0, child_process_1.execFileSync)("git", ["push", config.remote], {
+                    cwd: agentRoot,
+                    stdio: "pipe",
+                    timeout: 30000,
+                });
+            }
+            catch (retryErr) {
+                // Second failure -- write pending-sync.json
+                const retryError = retryErr instanceof Error ? retryErr.message : String(retryErr);
+                const pendingSyncPath = path.join(agentRoot, "state", "pending-sync.json");
+                fs.mkdirSync(path.join(agentRoot, "state"), { recursive: true });
+                fs.writeFileSync(pendingSyncPath, JSON.stringify({
+                    error: retryError,
+                    failedAt: new Date().toISOString(),
+                    paths: relativePaths,
+                }, null, 2), "utf-8");
+                (0, runtime_1.emitNervesEvent)({
+                    component: "heart",
+                    event: "heart.sync_push_error",
+                    message: "post-turn push failed after retry",
+                    meta: { agentRoot, error: retryError },
+                });
+                return { ok: false, error: retryError };
+            }
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.sync_push_end",
+            message: "post-turn push complete",
+            meta: { agentRoot, changedCount: relativePaths.length },
+        });
+        return { ok: true };
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.sync_push_error",
+            message: "post-turn push failed",
+            meta: { agentRoot, error },
+        });
+        return { ok: false, error };
+    }
+}

package/dist/heart/target-resolution.js

@@ -0,0 +1,127 @@
+"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 === "mcp") {
+        // MCP can't push (no proactive API), but can queue — dev tool picks up via check_response
+        return { mode: "queue_only", reason: "MCP session — message queued for dev tool to pick up via check_response" };
+    }
+    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/tempo.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEMPO_BUDGETS = void 0;
+exports.deriveTempo = deriveTempo;
+exports.getTokenBudget = getTokenBudget;
+exports.detectTempoShift = detectTempoShift;
+const runtime_1 = require("../nerves/runtime");
+exports.TEMPO_BUDGETS = {
+    brief: { min: 150, max: 250 },
+    standard: { min: 450, max: 700 },
+    dense: { min: 900, max: 1100 },
+    crisis: { min: 700, max: 1000 },
+};
+const FIVE_MINUTES_MS = 5 * 60 * 1000;
+const TWO_HOURS_MS = 2 * 60 * 60 * 1000;
+function deriveMode(inputs) {
+    if (inputs.hasBlockers)
+        return "crisis";
+    if (inputs.openObligations > 3 || inputs.recentEpisodeCount > 10)
+        return "dense";
+    if (inputs.activeSessions > 0)
+        return "standard";
+    return "brief";
+}
+function deriveSignificance(inputs) {
+    if (inputs.highSalienceEpisodes > 0 || inputs.atRiskCareCount > 0)
+        return "high";
+    if (inputs.activeCareCount > 0)
+        return "medium";
+    return "low";
+}
+function deriveReentryDepth(inputs) {
+    if (inputs.lastActivityAgeMs < FIVE_MINUTES_MS)
+        return "warm";
+    if (inputs.lastActivityAgeMs < TWO_HOURS_MS)
+        return "cooled";
+    return "cold";
+}
+function computeEffectiveBudget(mode, significance, reentryDepth) {
+    const base = exports.TEMPO_BUDGETS[mode];
+    // Crisis always uses crisis budget regardless
+    if (mode === "crisis")
+        return { ...base };
+    const range = base.max - base.min;
+    // Start at the mode minimum
+    let effectiveMin = base.min;
+    // Significance pushes up within range
+    if (significance === "high") {
+        effectiveMin += Math.round(range * 0.5);
+    }
+    else if (significance === "medium") {
+        effectiveMin += Math.round(range * 0.25);
+    }
+    // Cold re-entry pushes up (need more context to re-orient)
+    if (reentryDepth === "cold") {
+        effectiveMin += Math.round(range * 0.3);
+    }
+    else if (reentryDepth === "cooled") {
+        effectiveMin += Math.round(range * 0.1);
+    }
+    // Clamp within mode range
+    effectiveMin = Math.min(effectiveMin, base.max);
+    return { min: effectiveMin, max: base.max };
+}
+function deriveTempo(inputs) {
+    const mode = deriveMode(inputs);
+    const significance = deriveSignificance(inputs);
+    const reentryDepth = deriveReentryDepth(inputs);
+    const effectiveBudget = computeEffectiveBudget(mode, significance, reentryDepth);
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.tempo_derived",
+        message: `tempo derived: ${mode}/${significance}/${reentryDepth}`,
+        meta: {
+            mode,
+            significance,
+            reentryDepth,
+            effectiveMin: effectiveBudget.min,
+            effectiveMax: effectiveBudget.max,
+        },
+    });
+    return { mode, significance, reentryDepth, effectiveBudget };
+}
+function getTokenBudget(state) {
+    return state.effectiveBudget;
+}
+function detectTempoShift(previous, current) {
+    if (!previous)
+        return true;
+    return (previous.mode !== current.mode
+        || previous.significance !== current.significance
+        || previous.reentryDepth !== current.reentryDepth);
+}

package/dist/heart/temporal-view.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTemporalView = buildTemporalView;
+const runtime_1 = require("../nerves/runtime");
+const episodes_1 = require("../arc/episodes");
+const obligations_1 = require("../arc/obligations");
+const cares_1 = require("../arc/cares");
+const intentions_1 = require("../arc/intentions");
+const presence_1 = require("../arc/presence");
+function buildTemporalView(agentRoot, options) {
+    const episodeLimit = options?.episodeLimit ?? 20;
+    const tempo = options?.tempo ?? "brief";
+    const recentEpisodes = options?.preloaded?.recentEpisodes ?? (0, episodes_1.readRecentEpisodes)(agentRoot, { limit: episodeLimit });
+    const activeObligations = options?.preloaded?.activeObligations ?? (0, obligations_1.readPendingObligations)(agentRoot);
+    const activeCares = options?.preloaded?.activeCares ?? (0, cares_1.readActiveCares)(agentRoot);
+    const openIntentions = (0, intentions_1.readOpenIntentions)(agentRoot);
+    const peerPresence = (0, presence_1.readPeerPresence)(agentRoot);
+    const view = {
+        recentEpisodes,
+        activeObligations,
+        activeCares,
+        openIntentions,
+        peerPresence,
+        tempo,
+        assembledAt: new Date().toISOString(),
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.temporal_view_assembled",
+        message: `temporal view assembled: ${recentEpisodes.length} episodes, ${activeObligations.length} obligations, ${activeCares.length} cares, ${openIntentions.length} intentions`,
+        meta: {
+            episodeCount: recentEpisodes.length,
+            obligationCount: activeObligations.length,
+            careCount: activeCares.length,
+            intentionCount: openIntentions.length,
+            peerCount: peerPresence.length,
+            tempo,
+        },
+    });
+    return view;
+}