@ouro.bot/cli 0.1.0-alpha.696 → 0.1.0-alpha.698

package/dist/heart/run-ledger.js

@@ -0,0 +1,247 @@
+"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.runLedgerHash = runLedgerHash;
+exports.usageMetadataFromUsageData = usageMetadataFromUsageData;
+exports.deriveRunLedgerIds = deriveRunLedgerIds;
+exports.createRunLedgerRecord = createRunLedgerRecord;
+exports.runLedgerPath = runLedgerPath;
+exports.appendRunLedgerRecord = appendRunLedgerRecord;
+exports.appendRunLedgerRecordNonFatal = appendRunLedgerRecordNonFatal;
+exports.readRunLedger = readRunLedger;
+const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../nerves/runtime");
+function sha256Hex(input) {
+    return (0, node_crypto_1.createHash)("sha256").update(input).digest("hex");
+}
+function canonicalJson(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map((entry) => canonicalJson(entry)).join(",")}]`;
+    }
+    if (value && typeof value === "object") {
+        const record = value;
+        return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+function hashValue(value) {
+    return sha256Hex(canonicalJson(value));
+}
+function runLedgerHash(value) {
+    return `sha256:${hashValue(value)}`;
+}
+function stableUnique(values) {
+    return [...new Set((values ?? []).filter((value) => typeof value === "string" && value.trim().length > 0))];
+}
+function numberOrZero(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function usageMetadataFromUsageData(usage, source) {
+    return {
+        source,
+        inputTokens: numberOrZero(usage?.input_tokens),
+        outputTokens: numberOrZero(usage?.output_tokens),
+        reasoningTokens: numberOrZero(usage?.reasoning_tokens),
+        totalTokens: numberOrZero(usage?.total_tokens),
+    };
+}
+function deriveRunLedgerIds(input) {
+    const targetHash = runLedgerHash(input.target);
+    const idempotencyKey = `idem_${hashValue({
+        agent: input.agent,
+        triggerType: input.triggerType,
+        sourceKind: input.sourceKind,
+        senseOrHabit: input.senseOrHabit,
+        scope: input.idempotencyScope ?? input.target,
+    }).slice(0, 32)}`;
+    const runId = `run_${hashValue({
+        agent: input.agent,
+        triggerType: input.triggerType,
+        sourceKind: input.sourceKind,
+        senseOrHabit: input.senseOrHabit,
+        targetHash,
+        idempotencyKey,
+        parentRunId: input.parentRunId ?? null,
+    }).slice(0, 24)}`;
+    return {
+        runId,
+        rootRunId: input.rootRunId ?? input.parentRunId ?? runId,
+        ...(input.parentRunId ? { parentRunId: input.parentRunId } : {}),
+        idempotencyKey,
+        targetHash,
+    };
+}
+function createRunLedgerRecord(input) {
+    const ids = deriveRunLedgerIds(input);
+    return {
+        schemaVersion: 1,
+        recordedAt: new Date().toISOString(),
+        ...ids,
+        agent: input.agent,
+        triggerType: input.triggerType,
+        sourceKind: input.sourceKind,
+        senseOrHabit: input.senseOrHabit,
+        lifecycle: input.lifecycle,
+        startedAt: input.startedAt,
+        ...(input.endedAt ? { endedAt: input.endedAt } : {}),
+        ...(input.usage ? { usage: input.usage } : {}),
+        ...(input.provider ? { provider: input.provider } : {}),
+        ...(input.model ? { model: input.model } : {}),
+        ...(input.sessionRef ? { sessionRef: input.sessionRef } : {}),
+        contextPacketIds: stableUnique(input.contextPacketIds),
+        contentStored: false,
+        ...(input.errorName ? { errorName: input.errorName } : {}),
+        ...(input.errorCode ? { errorCode: input.errorCode } : {}),
+    };
+}
+function runLedgerPath(agentRoot) {
+    return path.join(agentRoot, "state", "run-ledger", "runs.jsonl");
+}
+function appendRunLedgerRecord(agentRoot, record) {
+    const filePath = runLedgerPath(agentRoot);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.appendFileSync(filePath, `${JSON.stringify(record)}\n`, "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.run_ledger_recorded",
+        message: "recorded causal run ledger row",
+        meta: {
+            agent: record.agent,
+            runId: record.runId,
+            triggerType: record.triggerType,
+            sourceKind: record.sourceKind,
+            lifecycle: record.lifecycle,
+            senseOrHabit: record.senseOrHabit,
+        },
+    });
+}
+function appendRunLedgerRecordNonFatal(agentRoot, record) {
+    try {
+        appendRunLedgerRecord(agentRoot, record);
+        return true;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "heart",
+            event: "heart.run_ledger_record_error",
+            message: "failed to record causal run ledger row",
+            meta: {
+                agent: record.agent,
+                runId: record.runId,
+                lifecycle: record.lifecycle,
+                error: String(error),
+            },
+        });
+        return false;
+    }
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function isUsageMetadata(value) {
+    const usage = value;
+    return !!usage
+        && (usage.source === "provider" || usage.source === "none" || usage.source === "reported-unavailable")
+        && typeof usage.inputTokens === "number"
+        && typeof usage.outputTokens === "number"
+        && typeof usage.reasoningTokens === "number"
+        && typeof usage.totalTokens === "number";
+}
+function isSessionRef(value) {
+    const ref = value;
+    return !!ref
+        && typeof ref.channel === "string"
+        && typeof ref.keyHash === "string";
+}
+function isRunLedgerRecord(value) {
+    const record = value;
+    return !!record
+        && record.schemaVersion === 1
+        && typeof record.recordedAt === "string"
+        && typeof record.runId === "string"
+        && typeof record.rootRunId === "string"
+        && (record.parentRunId === undefined || typeof record.parentRunId === "string")
+        && typeof record.idempotencyKey === "string"
+        && typeof record.agent === "string"
+        && (record.triggerType === "inbound" || record.triggerType === "habit" || record.triggerType === "reload" || record.triggerType === "recovery" || record.triggerType === "manual")
+        && (record.sourceKind === "sense" || record.sourceKind === "private-runtime" || record.sourceKind === "daemon" || record.sourceKind === "cli")
+        && typeof record.senseOrHabit === "string"
+        && typeof record.targetHash === "string"
+        && (record.lifecycle === "started" || record.lifecycle === "completed" || record.lifecycle === "skipped" || record.lifecycle === "blocked" || record.lifecycle === "error")
+        && typeof record.startedAt === "string"
+        && (record.endedAt === undefined || typeof record.endedAt === "string")
+        && (record.usage === undefined || isUsageMetadata(record.usage))
+        && (record.provider === undefined || typeof record.provider === "string")
+        && (record.model === undefined || typeof record.model === "string")
+        && (record.sessionRef === undefined || isSessionRef(record.sessionRef))
+        && isStringArray(record.contextPacketIds)
+        && record.contentStored === false
+        && (record.errorName === undefined || typeof record.errorName === "string")
+        && (record.errorCode === undefined || typeof record.errorCode === "string");
+}
+function emitMalformedRunLedgerRow(lineNumber, reason) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "heart",
+        event: "heart.run_ledger_malformed",
+        message: "skipped malformed causal run ledger row",
+        meta: { lineNumber, reason },
+    });
+}
+function readRunLedger(agentRoot) {
+    const filePath = runLedgerPath(agentRoot);
+    if (!fs.existsSync(filePath))
+        return [];
+    const rows = [];
+    const lines = fs.readFileSync(filePath, "utf-8").split("\n").filter((line) => line.trim().length > 0);
+    lines.forEach((line, index) => {
+        try {
+            const parsed = JSON.parse(line);
+            if (isRunLedgerRecord(parsed)) {
+                rows.push(parsed);
+            }
+            else {
+                emitMalformedRunLedgerRow(index + 1, "invalid shape");
+            }
+        }
+        catch (error) {
+            emitMalformedRunLedgerRow(index + 1, String(error));
+        }
+    });
+    return rows;
+}

package/dist/heart/runtime-credentials.js

@@ -43,6 +43,7 @@ exports.applyRuntimeCredentialBootstrapMessage = applyRuntimeCredentialBootstrap
 exports.waitForRuntimeCredentialBootstrap = waitForRuntimeCredentialBootstrap;
 exports.refreshRuntimeCredentialConfig = refreshRuntimeCredentialConfig;
 exports.refreshMachineRuntimeCredentialConfig = refreshMachineRuntimeCredentialConfig;
+exports.mergeRuntimeCredentialConfig = mergeRuntimeCredentialConfig;
 exports.upsertRuntimeCredentialConfig = upsertRuntimeCredentialConfig;
 exports.upsertMachineRuntimeCredentialConfig = upsertMachineRuntimeCredentialConfig;
 exports.mergeMachineRuntimeCredentialConfig = mergeMachineRuntimeCredentialConfig;
@@ -315,17 +316,25 @@ async function refreshRuntimeCredentialConfig(agentName, options = {}) {
 async function refreshMachineRuntimeCredentialConfig(agentName, machineId, options = {}) {
     return refreshRuntimeCredentialConfigItem(agentName, machineRuntimeConfigItemName(machineId), cacheMachineResult, options);
 }
-function mergeRuntimeCredentialConfig(base, patch) {
+function mergeRuntimeCredentialConfigObjects(base, patch) {
     const next = { ...base };
     for (const key of Object.keys(patch)) {
         const baseValue = next[key];
         const patchValue = patch[key];
         next[key] = isRecord(baseValue) && isRecord(patchValue)
-            ? mergeRuntimeCredentialConfig(baseValue, patchValue)
+            ? mergeRuntimeCredentialConfigObjects(baseValue, patchValue)
             : patchValue;
     }
     return next;
 }
+async function mergeRuntimeCredentialConfig(agentName, patch, now = new Date()) {
+    const current = await refreshRuntimeCredentialConfig(agentName);
+    if (!current.ok && current.reason !== "missing") {
+        throw new Error(`cannot merge runtime config at ${current.itemPath}: ${current.error}`);
+    }
+    const base = current.ok ? current.config : {};
+    return upsertRuntimeCredentialConfig(agentName, mergeRuntimeCredentialConfigObjects(base, patch), now);
+}
 async function upsertRuntimeCredentialConfig(agentName, config, now = new Date()) {
     const payload = {
         schemaVersion: 1,
@@ -381,7 +390,7 @@ async function mergeMachineRuntimeCredentialConfig(agentName, machineId, patch,
         throw new Error(`cannot merge machine runtime config at ${current.itemPath}: ${current.error}`);
     }
     const base = current.ok ? current.config : {};
-    return upsertMachineRuntimeCredentialConfig(agentName, machineId, mergeRuntimeCredentialConfig(base, patch), now);
+    return upsertMachineRuntimeCredentialConfig(agentName, machineId, mergeRuntimeCredentialConfigObjects(base, patch), now);
 }
 function resetRuntimeCredentialConfigCache() {
     cachedRuntimeConfigs = new Map();

package/dist/mind/prompt-budget.js

@@ -0,0 +1,380 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROMPT_BUDGET_FALLBACK_CONTEXT_WINDOW_TOKENS = exports.PROMPT_BUDGET_POLICY_VERSION = void 0;
+exports.estimatePromptBudgetTokensForMessage = estimatePromptBudgetTokensForMessage;
+exports.estimatePromptBudgetTokens = estimatePromptBudgetTokens;
+exports.applyPromptBudget = applyPromptBudget;
+const runtime_1 = require("../nerves/runtime");
+exports.PROMPT_BUDGET_POLICY_VERSION = "prompt-budget/v1";
+exports.PROMPT_BUDGET_FALLBACK_CONTEXT_WINDOW_TOKENS = 24_000;
+function contentCharacters(content) {
+    if (typeof content === "string")
+        return content.length;
+    if (!content)
+        return 0;
+    if (Array.isArray(content)) {
+        return content.reduce((total, part) => {
+            if (typeof part === "string")
+                return total + part.length;
+            if (!part || typeof part !== "object")
+                return total;
+            const record = part;
+            if (typeof record.text === "string")
+                return total + record.text.length;
+            if (typeof record.content === "string")
+                return total + record.content.length;
+            try {
+                return total + JSON.stringify(record).length;
+            }
+            catch {
+                return total;
+            }
+        }, 0);
+    }
+    if (typeof content === "object") {
+        const record = content;
+        if (typeof record.text === "string")
+            return record.text.length;
+        if (typeof record.content === "string")
+            return record.content.length;
+        try {
+            return JSON.stringify(record).length;
+        }
+        catch {
+            return 0;
+        }
+    }
+    return 0;
+}
+function toolCallCharacters(toolCalls) {
+    if (!Array.isArray(toolCalls))
+        return 0;
+    let total = 0;
+    for (const call of toolCalls) {
+        if (!call || typeof call !== "object")
+            continue;
+        const record = call;
+        if (typeof record.id === "string")
+            total += record.id.length;
+        const fn = record.function;
+        if (fn && typeof fn === "object") {
+            const fnRecord = fn;
+            if (typeof fnRecord.name === "string")
+                total += fnRecord.name.length;
+            if (typeof fnRecord.arguments === "string")
+                total += fnRecord.arguments.length;
+        }
+    }
+    return total;
+}
+function estimatePromptBudgetTokensForMessage(message) {
+    const record = message;
+    let characters = 0;
+    if (typeof record.role === "string")
+        characters += record.role.length;
+    if (typeof record.name === "string")
+        characters += record.name.length;
+    if (typeof record.tool_call_id === "string")
+        characters += record.tool_call_id.length;
+    characters += contentCharacters(record.content);
+    characters += toolCallCharacters(record.tool_calls);
+    return Math.ceil(characters / 4);
+}
+function estimatePromptBudgetTokens(messages) {
+    return messages.reduce((total, message) => total + estimatePromptBudgetTokensForMessage(message), 0);
+}
+function itemTokens(item) {
+    return estimatePromptBudgetTokens(item.messages);
+}
+function cloneMessage(message) {
+    return { ...message };
+}
+function messageText(message) {
+    return typeof message.content === "string" ? message.content : "";
+}
+function isSenseContextPacketText(text) {
+    return /^Untrusted\s+\S+\s+context for this same thread\./.test(text);
+}
+function sourceRefsFrom(text) {
+    return [...new Set(text.match(/\bbbmsg:[^\]\s,]+/g) ?? [])];
+}
+function compactSenseContextItem(item) {
+    const message = item.messages[0];
+    const text = messageText(message);
+    const firstLine = text.split("\n").find((line) => line.trim().length > 0);
+    const refs = sourceRefsFrom(text);
+    const content = [
+        firstLine,
+        `[prompt budget compacted message excerpts; source refs retained: ${refs.length > 0 ? refs.join(", ") : "none"}]`,
+    ].join("\n");
+    return {
+        ...item,
+        compacted: true,
+        messages: [{ ...cloneMessage(message), content }],
+    };
+}
+const SYSTEM_MARKERS = [
+    { marker: "## from my kept record", source: "kept-memory", priority: 5 },
+    { marker: "## retrieved from my Desk record diary", source: "kept-memory", priority: 5 },
+    { marker: "## habit receipt", source: "habit-receipt", priority: 6 },
+    { marker: "## run ledger", source: "habit-receipt", priority: 6 },
+    { marker: "## diagnostics", source: "diagnostics", priority: 7 },
+    { marker: "## doctor", source: "diagnostics", priority: 7 },
+    { marker: "## incident bundle", source: "diagnostics", priority: 7 },
+    { marker: "## replay", source: "diagnostics", priority: 7 },
+];
+function classifySystemSegment(text) {
+    const lower = text.toLowerCase();
+    if (lower.includes("habit receipt") || lower.includes("run ledger"))
+        return { source: "habit-receipt", priority: 6 };
+    if (lower.includes("diagnostics") || lower.includes("doctor") || lower.includes("incident bundle") || lower.includes("replay")) {
+        return { source: "diagnostics", priority: 7 };
+    }
+    return { source: "system-prompt", priority: 1 };
+}
+function systemItems(message, index) {
+    const text = messageText(message);
+    if (isSenseContextPacketText(text)) {
+        return [{
+                id: `system:${index}:context`,
+                priority: 4,
+                source: "sense-context-packet",
+                messages: [cloneMessage(message)],
+                originalMessageCount: 1,
+            }];
+    }
+    const markerPositions = SYSTEM_MARKERS
+        .map((marker) => ({ ...marker, start: text.toLowerCase().indexOf(marker.marker.toLowerCase()) }))
+        .filter((entry) => entry.start >= 0)
+        .sort((left, right) => left.start - right.start);
+    if (markerPositions.length === 0) {
+        const classified = classifySystemSegment(text);
+        return [{
+                id: `system:${index}:0`,
+                priority: classified.priority,
+                source: classified.source,
+                messages: [cloneMessage(message)],
+                originalMessageCount: 1,
+            }];
+    }
+    const segments = [];
+    if (markerPositions[0].start > 0) {
+        segments.push({ start: 0, end: markerPositions[0].start, source: "system-prompt", priority: 1 });
+    }
+    markerPositions.forEach((position, markerIndex) => {
+        segments.push({
+            start: position.start,
+            end: markerPositions[markerIndex + 1]?.start ?? text.length,
+            source: position.source,
+            priority: position.priority,
+        });
+    });
+    return segments
+        .map((segment, segmentIndex) => {
+        const content = text.slice(segment.start, segment.end).trim();
+        if (!content)
+            return null;
+        return {
+            id: `system:${index}:${segmentIndex}`,
+            priority: segment.priority,
+            source: segment.source,
+            messages: [{ ...cloneMessage(message), content }],
+            originalMessageCount: segmentIndex === 0 ? 1 : 0,
+        };
+    })
+        .filter((item) => item !== null);
+}
+function assistantHasToolCalls(message) {
+    return message.role === "assistant"
+        && Array.isArray(message.tool_calls)
+        && message.tool_calls.length > 0;
+}
+function nonSystemSourceFor(messages) {
+    const text = messages.map(messageText).join("\n").toLowerCase();
+    if (text.includes("habit receipt") || text.includes("run ledger"))
+        return "habit-receipt";
+    if (text.includes("diagnostics") || text.includes("doctor") || text.includes("incident bundle") || text.includes("replay"))
+        return "diagnostics";
+    return "recent-session-tail";
+}
+function buildPromptBudgetItems(messages) {
+    const rawItems = [];
+    let index = 0;
+    while (index < messages.length) {
+        const message = messages[index];
+        if (message.role === "system") {
+            rawItems.push(...systemItems(message, index));
+            index += 1;
+            continue;
+        }
+        if (assistantHasToolCalls(message)) {
+            const block = [cloneMessage(message)];
+            let next = index + 1;
+            while (messages[next]?.role === "tool") {
+                block.push(cloneMessage(messages[next]));
+                next += 1;
+            }
+            rawItems.push({
+                id: `conversation:${index}`,
+                priority: 3,
+                source: nonSystemSourceFor(block),
+                messages: block,
+                originalMessageCount: block.length,
+            });
+            index = next;
+            continue;
+        }
+        rawItems.push({
+            id: `conversation:${index}`,
+            priority: 3,
+            source: nonSystemSourceFor([message]),
+            messages: [cloneMessage(message)],
+            originalMessageCount: 1,
+        });
+        index += 1;
+    }
+    const lastUserItemIndex = rawItems.findLastIndex((item) => item.messages.some((message) => message.role === "user"));
+    const latestToolItemIndex = rawItems.findLastIndex((item) => item.messages.some((message) => message.role === "tool" || assistantHasToolCalls(message)));
+    return rawItems.map((item, itemIndex) => {
+        if (itemIndex === lastUserItemIndex) {
+            return { ...item, priority: 1, source: "current-user-message" };
+        }
+        if (itemIndex === latestToolItemIndex) {
+            return { ...item, priority: 1, source: "active-tool-result-context" };
+        }
+        if (item.messages.every((message) => message.role === "system"))
+            return item;
+        if (item.source === "habit-receipt")
+            return { ...item, priority: 6 };
+        if (item.source === "diagnostics")
+            return { ...item, priority: 7 };
+        if (lastUserItemIndex >= 0 && itemIndex < lastUserItemIndex)
+            return { ...item, priority: 8, source: "older-session-history" };
+        return { ...item, priority: 3, source: "recent-session-tail" };
+    });
+}
+function flattenItems(items) {
+    return items.flatMap((item) => item.messages.map(cloneMessage));
+}
+function budgetFor(input) {
+    const contextWindowTokens = typeof input.contextWindowTokens === "number" && Number.isFinite(input.contextWindowTokens) && input.contextWindowTokens > 0
+        ? Math.floor(input.contextWindowTokens)
+        : exports.PROMPT_BUDGET_FALLBACK_CONTEXT_WINDOW_TOKENS;
+    const outputReserveRatio = input.outputReserveRatio ?? 0.2;
+    const protocolReserveRatio = input.protocolReserveRatio ?? 0.1;
+    const outputReserveTokens = Math.floor(contextWindowTokens * outputReserveRatio);
+    const protocolReserveTokens = Math.floor(contextWindowTokens * protocolReserveRatio);
+    return {
+        provider: input.provider,
+        model: input.model,
+        contextWindowTokens,
+        outputReserveTokens,
+        protocolReserveTokens,
+        inputTokenLimit: Math.max(0, contextWindowTokens - outputReserveTokens - protocolReserveTokens),
+    };
+}
+function totalItemTokens(items) {
+    return estimatePromptBudgetTokens(flattenItems(items));
+}
+function truncationFor(item, reason, beforeTokens, afterTokens) {
+    return {
+        source: item.source,
+        reason,
+        beforeTokens,
+        afterTokens,
+        messageCount: item.originalMessageCount,
+    };
+}
+function emitPromptBudgetEvent(result) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.prompt_budget_applied",
+        message: "applied final prompt budget before provider turn",
+        meta: {
+            status: result.status,
+            provider: result.budget.provider,
+            model: result.budget.model,
+            contextWindowTokens: result.budget.contextWindowTokens,
+            inputTokenLimit: result.budget.inputTokenLimit,
+            estimatedBeforeTokens: result.stats.estimatedBeforeTokens,
+            estimatedAfterTokens: result.stats.estimatedAfterTokens,
+            droppedMessages: result.stats.droppedMessages,
+            truncationCount: result.stats.truncations.length,
+        },
+    });
+}
+function applyPromptBudget(input) {
+    const budget = budgetFor(input);
+    const estimatedBeforeTokens = estimatePromptBudgetTokens(input.messages);
+    const truncations = [];
+    let droppedMessages = 0;
+    if (estimatedBeforeTokens <= budget.inputTokenLimit) {
+        const result = {
+            policyVersion: exports.PROMPT_BUDGET_POLICY_VERSION,
+            status: "within_budget",
+            messages: input.messages.map(cloneMessage),
+            budget,
+            stats: {
+                estimatedBeforeTokens,
+                estimatedAfterTokens: estimatedBeforeTokens,
+                originalMessages: input.messages.length,
+                finalMessages: input.messages.length,
+                droppedMessages,
+                truncations,
+            },
+        };
+        emitPromptBudgetEvent(result);
+        return result;
+    }
+    let items = buildPromptBudgetItems(input.messages);
+    for (const priority of [8, 7, 6, 5, 4, 3]) {
+        if (totalItemTokens(items) <= budget.inputTokenLimit)
+            break;
+        if (priority === 4) {
+            items = items.map((item) => {
+                if (item.priority !== 4 || item.compacted)
+                    return item;
+                const beforeTokens = itemTokens(item);
+                const compacted = compactSenseContextItem(item);
+                const afterTokens = itemTokens(compacted);
+                if (afterTokens < beforeTokens) {
+                    truncations.push(truncationFor(item, "compacted message excerpts to source refs", beforeTokens, afterTokens));
+                }
+                return compacted;
+            });
+            if (totalItemTokens(items) <= budget.inputTokenLimit)
+                break;
+        }
+        for (let itemIndex = 0; itemIndex < items.length && totalItemTokens(items) > budget.inputTokenLimit; itemIndex += 1) {
+            const item = items[itemIndex];
+            if (item.priority !== priority)
+                continue;
+            const beforeTokens = itemTokens(item);
+            droppedMessages += item.originalMessageCount;
+            truncations.push(truncationFor(item, "dropped to fit prompt budget", beforeTokens, 0));
+            items = items.filter((_, index) => index !== itemIndex);
+            itemIndex -= 1;
+        }
+    }
+    const messages = flattenItems(items);
+    const estimatedAfterTokens = estimatePromptBudgetTokens(messages);
+    const status = estimatedAfterTokens <= budget.inputTokenLimit
+        ? "trimmed"
+        : "over_budget";
+    const result = {
+        policyVersion: exports.PROMPT_BUDGET_POLICY_VERSION,
+        status,
+        messages,
+        budget,
+        stats: {
+            estimatedBeforeTokens,
+            estimatedAfterTokens,
+            originalMessages: input.messages.length,
+            finalMessages: messages.length,
+            droppedMessages,
+            truncations,
+        },
+    };
+    emitPromptBudgetEvent(result);
+    return result;
+}

package/dist/repertoire/tools-base.js

@@ -26,6 +26,7 @@ const tools_obligations_1 = require("./tools-obligations");
 const tools_evolution_1 = require("./tools-evolution");
 const tools_runtime_1 = require("./tools-runtime");
 const tools_orientation_1 = require("./tools-orientation");
+const tools_rsvp_1 = require("./tools-rsvp");
 // Re-export flow tools for consumers that import them from tools-base
 var tools_flow_1 = require("./tools-flow");
 Object.defineProperty(exports, "ponderTool", { enumerable: true, get: function () { return tools_flow_1.ponderTool; } });
@@ -67,6 +68,7 @@ exports.baseToolDefinitions = [
     ...tools_evolution_1.evolutionToolDefinitions,
     ...tools_orientation_1.orientationToolDefinitions,
     ...tools_runtime_1.runtimeToolDefinitions,
+    ...tools_rsvp_1.rsvpToolDefinitions,
 ];
 // Convenience array of just the tool schemas (no handler/integration metadata).
 // Used by consumers that need the OpenAI function-tool format.