@ouro.bot/cli 0.1.0-alpha.92 → 0.1.0-alpha.920

package/dist/heart/target-resolution.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.listTargetSessionCandidates = listTargetSessionCandidates;
 exports.formatTargetSessionCandidates = formatTargetSessionCandidates;
-const session_recall_1 = require("./session-recall");
+const friends_1 = require("@ouro.bot/friends");
+const session_transcript_1 = require("./session-transcript");
 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 {
@@ -34,6 +34,10 @@ 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" };
     }
@@ -63,11 +67,11 @@ async function listTargetSessionCandidates(input) {
     const candidates = [];
     for (const entry of activity) {
         const friend = await input.friendStore.get(entry.friendId) ?? synthesizeFriendRecord(entry);
-        const trust = (0, trust_explanation_1.describeTrustContext)({
+        const trust = (0, friends_1.describeTrustContext)({
             friend,
             channel: entry.channel,
         });
-        const recall = await (0, session_recall_1.recallSession)({
+        const sessionTail = await (0, session_transcript_1.summarizeSessionTail)({
             sessionPath: entry.sessionPath,
             friendId: entry.friendId,
             channel: entry.channel,
@@ -76,9 +80,9 @@ async function listTargetSessionCandidates(input) {
             summarize: input.summarize,
             trustLevel: trust.level,
         });
-        const snapshot = recall.kind === "ok"
-            ? recall.snapshot
-            : recall.kind === "empty"
+        const snapshot = sessionTail.kind === "ok"
+            ? sessionTail.snapshot
+            : sessionTail.kind === "empty"
                 ? "recent focus: no recent visible messages"
                 : "recent focus: session transcript unavailable";
         const delivery = describeDelivery({

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;
+}

package/dist/heart/timeouts.js

@@ -0,0 +1,101 @@
+"use strict";
+/**
+ * Soft/hard timeout pattern for boot-path operations — Layer 2.
+ *
+ * Soft timeout = "log a warning, keep going". The op continues; the consumer
+ * records the warning and moves on.
+ * Hard timeout = "abort the op via AbortSignal". The underlying op is
+ * expected to honour the signal (Node child_process accepts `{ signal }`,
+ * fetch accepts `{ signal }`, etc.). When the signal aborts, the op should
+ * reject with an AbortError, and the wrapper returns
+ * `{ classification: "timeout-hard" }` rather than re-throwing.
+ *
+Two optional env overrides (currently only `GIT` is consumed):
+ *   - `OURO_BOOT_TIMEOUT_GIT_SOFT` / `OURO_BOOT_TIMEOUT_GIT_HARD` — boot
+ *     git operations (fetch / pull). Used when `envKey === "GIT"`.
+ *
+ * Env values are parsed as integer milliseconds. Non-numeric or non-positive
+ * values are ignored (the explicit `softMs` / `hardMs` defaults from the
+ * caller win in that case).
+ *
+ * Pattern guarantee: timers cleared on resolve / reject so the function
+ * holds no refs after settlement. Important because `ouro up` chains
+ * many of these and a leaking timer would block process exit.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runWithTimeouts = runWithTimeouts;
+function readEnvMs(name) {
+    const raw = process.env[name];
+    if (raw === undefined || raw === null)
+        return null;
+    const parsed = Number.parseInt(raw, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return null;
+    return parsed;
+}
+function resolveTimeouts(options) {
+    let softMs = options.softMs;
+    let hardMs = options.hardMs;
+    if (options.envKey === "GIT") {
+        const envSoft = readEnvMs("OURO_BOOT_TIMEOUT_GIT_SOFT");
+        if (envSoft !== null)
+            softMs = envSoft;
+        const envHard = readEnvMs("OURO_BOOT_TIMEOUT_GIT_HARD");
+        if (envHard !== null)
+            hardMs = envHard;
+    }
+    return { softMs, hardMs };
+}
+/**
+ * Run `fn` with soft and hard timeouts.
+ *
+ * - Returns `{ result }` on success.
+ * - Returns `{ classification: "timeout-hard", warnings }` when aborted.
+ * - Returns `{ result, warnings: [...] }` when soft tripped but op completed.
+ * - Rejects when `fn` throws a non-abort error (callers can wrap with
+ *   classifier).
+ */
+async function runWithTimeouts(fn, options) {
+    const { softMs, hardMs } = resolveTimeouts(options);
+    const controller = new AbortController();
+    const warnings = [];
+    let softTimer = setTimeout(() => {
+        softTimer = null;
+        warnings.push(`${options.label}: soft timeout exceeded (${softMs}ms) — warning, continuing until hard cut`);
+    }, softMs);
+    let hardTimer = setTimeout(() => {
+        hardTimer = null;
+        controller.abort();
+    }, hardMs);
+    const cleanup = () => {
+        if (softTimer !== null) {
+            clearTimeout(softTimer);
+            softTimer = null;
+        }
+        if (hardTimer !== null) {
+            clearTimeout(hardTimer);
+            hardTimer = null;
+        }
+    };
+    try {
+        const result = await fn(controller.signal);
+        cleanup();
+        // If the abort fired and the op resolved gracefully (e.g., the inner
+        // function caught the AbortError and returned a structured result), we
+        // still classify the outcome as timeout-hard — the op was aborted from
+        // the caller's perspective even if no exception propagated. The caller
+        // can ignore the classification and use `result` if both are present.
+        if (controller.signal.aborted) {
+            return { classification: "timeout-hard", warnings };
+        }
+        return { result, warnings };
+    }
+    catch (err) {
+        cleanup();
+        if (controller.signal.aborted) {
+            // Hard timeout fired — abort wins over whatever error the op threw.
+            return { classification: "timeout-hard", warnings };
+        }
+        throw err;
+    }
+}

package/dist/heart/tool-activity-callbacks.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createToolActivityCallbacks = createToolActivityCallbacks;
+const tool_description_1 = require("./tool-description");
+const runtime_1 = require("../nerves/runtime");
+function createToolActivityCallbacks(options) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.tool_activity_callbacks_created",
+        message: "tool activity callbacks initialized",
+        meta: {},
+    });
+    // Track the last description so we can reference it in END messages
+    let lastDescription = null;
+    // Track in-flight hidden tools so onToolEnd can SYMMETRICALLY suppress
+    // emission for the same tools that onToolStart already suppresses.
+    // Without this, a rejected hidden tool (e.g. settle blocked by the
+    // mustResolveBeforeHandoff gate or the private-runtime attention-queue gate)
+    // would emit "✗ <previous visible tool's description> — <hidden tool's args summary>"
+    // because lastDescription persists across calls and the hidden tool's summary
+    // (built via summarizeArgs) leaks args like settle's `answer`/`intent` into
+    // the visible chat. Counter map (not bool) so concurrent hidden starts don't
+    // underflow if ends arrive in any order.
+    const hiddenInFlight = new Map();
+    return {
+        onToolStart(name, args) {
+            const description = (0, tool_description_1.humanReadableToolDescription)(name, args);
+            if (description === null) {
+                // hidden tool (settle, rest, descend, observe, speak) — track so the
+                // matching onToolEnd is also suppressed symmetrically.
+                hiddenInFlight.set(name, (hiddenInFlight.get(name) ?? 0) + 1);
+                return;
+            }
+            lastDescription = description;
+            options.onDescription(description);
+        },
+        onToolEnd(name, summary, success) {
+            const hiddenCount = hiddenInFlight.get(name) ?? 0;
+            if (hiddenCount > 0) {
+                // Hidden tool's start was suppressed; suppress its end too.
+                if (hiddenCount === 1)
+                    hiddenInFlight.delete(name);
+                else
+                    hiddenInFlight.set(name, hiddenCount - 1);
+                return;
+            }
+            const desc = lastDescription ?? name;
+            // Strip trailing "..." from description for the result line
+            const cleanDesc = desc.endsWith("...") ? desc.slice(0, -3) : desc;
+            if (!success) {
+                options.onFailure(`✗ ${cleanDesc} — ${summary}`);
+                return;
+            }
+            if (options.isDebug()) {
+                options.onResult(`✓ ${cleanDesc}`);
+            }
+        },
+    };
+}