@ouro.bot/cli 0.1.0-alpha.695 → 0.1.0-alpha.697

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/heart/work-card.js

@@ -44,14 +44,6 @@ const evolution_1 = require("../arc/evolution");
 const obligations_1 = require("../arc/obligations");
 const packets_1 = require("../arc/packets");
 const flight_recorder_1 = require("../arc/flight-recorder");
-const ACTIVE_PACKET_STATUSES = new Set([
-    "drafting",
-    "processing",
-    "validating",
-    "collaborating",
-    "paused",
-    "blocked",
-]);
 function isoFromMs(ms) {
     return new Date(ms).toISOString();
 }
@@ -244,9 +236,7 @@ function buildWorkCard(agentName, agentRoot, options = {}) {
     const sourceIssues = scanArcSourceIssues(agentRoot);
     const owed = (0, obligations_1.readPendingObligations)(agentRoot).map(obligationItem);
     const returnObligations = (0, obligations_1.listActiveReturnObligationsForRoot)(agentRoot, { now: options.nowMs }).map(returnObligationItem);
-    const activePackets = (0, packets_1.listPonderPackets)(agentRoot)
-        .filter((packet) => ACTIVE_PACKET_STATUSES.has(packet.status))
-        .map(packetItem);
+    const activePackets = (0, packets_1.listActivePonderPackets)(agentRoot, { now: options.nowMs }).map(packetItem);
     const evolutionCases = (0, evolution_1.listOpenEvolutionCases)(agentRoot).map(evolutionItem);
     const activeWork = [...activePackets, ...evolutionCases];
     const waiting = waitingOnHuman([...owed, ...returnObligations, ...activeWork]);

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.

package/dist/repertoire/tools-obligations.js

@@ -39,6 +39,7 @@ const identity_1 = require("../heart/identity");
 const runtime_1 = require("../nerves/runtime");
 const json_store_1 = require("../arc/json-store");
 const obligations_1 = require("../arc/obligations");
+const packets_1 = require("../arc/packets");
 /**
  * `let_go` lets the agent release a held work item from its attention loop.
  *
@@ -61,6 +62,40 @@ function outerObligationsDir(agentRoot) {
 function readOuterObligation(agentRoot, id) {
     return (0, json_store_1.readJsonFile)(outerObligationsDir(agentRoot), id) ?? null;
 }
+function completeRelatedPacket(agentRoot, packet, relation) {
+    try {
+        (0, packets_1.completePonderPacket)(agentRoot, packet.id);
+        (0, runtime_1.emitNervesEvent)({
+            component: "repertoire",
+            event: "repertoire.packet_completed_for_released_obligation",
+            message: "linked packet completed for released return obligation",
+            meta: { ...relation, packetId: packet.id },
+        });
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "repertoire",
+            event: "repertoire.packet_completion_for_released_obligation_failed",
+            message: "failed to complete linked packet for released return obligation",
+            meta: {
+                ...relation,
+                packetId: packet.id,
+                error: error instanceof Error ? error.message : String(error),
+            },
+        });
+    }
+}
+function completePacketsForReturnObligation(agentRoot, returnObligationId) {
+    for (const packet of (0, packets_1.listPonderPacketsByRelatedReturnObligationId)(agentRoot, returnObligationId)) {
+        completeRelatedPacket(agentRoot, packet, { returnObligationId });
+    }
+}
+function completePacketsForObligation(agentRoot, obligationId) {
+    for (const packet of (0, packets_1.listPonderPacketsByRelatedObligationId)(agentRoot, obligationId)) {
+        completeRelatedPacket(agentRoot, packet, { obligationId });
+    }
+}
 function letGo(args, agentRoot, agentName) {
     if (typeof args.id !== "string" || args.id.trim().length === 0) {
         return JSON.stringify({ error: "id is required" });
@@ -73,6 +108,7 @@ function letGo(args, agentRoot, agentName) {
     const ret = (0, obligations_1.readReturnObligation)(agentName, id);
     if (ret) {
         if (ret.status === "returned" || ret.status === "deferred") {
+            completePacketsForReturnObligation(agentRoot, id);
             return JSON.stringify({ kind: "return_obligation", id, already: ret.status });
         }
         (0, obligations_1.advanceReturnObligation)(agentName, id, {
@@ -80,6 +116,7 @@ function letGo(args, agentRoot, agentName) {
             returnedAt: Date.now(),
             returnTarget: "surface",
         });
+        completePacketsForReturnObligation(agentRoot, id);
         (0, runtime_1.emitNervesEvent)({
             component: "repertoire",
             event: "repertoire.obligation_let_go",
@@ -92,9 +129,11 @@ function letGo(args, agentRoot, agentName) {
     const outer = readOuterObligation(agentRoot, id);
     if (outer) {
         if (outer.status === "fulfilled") {
+            completePacketsForObligation(agentRoot, id);
             return JSON.stringify({ kind: "obligation", id, already: "fulfilled" });
         }
         (0, obligations_1.fulfillObligation)(agentRoot, id);
+        completePacketsForObligation(agentRoot, id);
         if (reason !== null) {
             // Persist the dismissal reason as the obligation's latestNote so future-me
             // can read why this was released (the nerves event also captures it).

package/dist/repertoire/tools-rsvp.js

@@ -0,0 +1,139 @@
+"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.rsvpToolDefinitions = void 0;
+const fs = __importStar(require("node:fs"));
+const runtime_1 = require("../nerves/runtime");
+const query_1 = require("../rsvp/query");
+const snapshot_1 = require("../rsvp/snapshot");
+function readSnapshot(snapshotPath) {
+    if (!snapshotPath || snapshotPath.trim().length === 0) {
+        return { ok: false, reason: "missing", message: "RSVP snapshot not found." };
+    }
+    try {
+        const raw = fs.readFileSync(snapshotPath, "utf-8");
+        const parsed = (0, snapshot_1.parseRsvpSnapshot)(JSON.parse(raw));
+        if (!parsed.ok) {
+            return { ok: false, reason: "invalid", message: "RSVP snapshot could not be read or failed integrity validation." };
+        }
+        return { ok: true, snapshot: parsed.snapshot };
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+            return { ok: false, reason: "missing", message: "RSVP snapshot not found." };
+        }
+        return { ok: false, reason: "invalid", message: "RSVP snapshot could not be read or failed integrity validation." };
+    }
+}
+function emitToolRead(toolName, result) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "repertoire",
+        event: "repertoire.rsvp_tool_read",
+        message: "RSVP tool read snapshot",
+        meta: result.ok
+            ? { toolName, snapshotId: result.snapshot.snapshotId, total: result.snapshot.summary.total }
+            : { toolName, reason: result.reason },
+    });
+}
+exports.rsvpToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "rsvp_query",
+                description: "answer deterministic questions about a native RSVP snapshot file, such as who is pending, declined, attending, unknown, or matching a guest name.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        snapshot_path: {
+                            type: "string",
+                            description: "absolute path to a native RSVP snapshot JSON file.",
+                        },
+                        query: {
+                            type: "string",
+                            description: "natural-language query or guest-name filter.",
+                        },
+                        status: {
+                            type: "string",
+                            enum: ["attending", "declined", "pending", "unknown", "all"],
+                            description: "optional explicit RSVP status filter.",
+                        },
+                    },
+                    required: ["snapshot_path"],
+                },
+            },
+        },
+        handler: async (args) => {
+            const result = readSnapshot(args.snapshot_path);
+            emitToolRead("rsvp_query", result);
+            if (!result.ok)
+                return result.message;
+            return (0, query_1.queryRsvpSnapshot)(result.snapshot, {
+                query: args.query,
+                status: args.status,
+            }).text;
+        },
+        summaryKeys: ["snapshot_path", "query", "status"],
+        riskProfile: { mutates: "none", risk: "low", reason: "reads a local native RSVP snapshot" },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "rsvp_summary",
+                description: "summarize counts and provenance for a native RSVP snapshot file.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        snapshot_path: {
+                            type: "string",
+                            description: "absolute path to a native RSVP snapshot JSON file.",
+                        },
+                    },
+                    required: ["snapshot_path"],
+                },
+            },
+        },
+        handler: async (args) => {
+            const result = readSnapshot(args.snapshot_path);
+            emitToolRead("rsvp_summary", result);
+            if (!result.ok)
+                return result.message;
+            return (0, query_1.summarizeRsvpSnapshot)(result.snapshot);
+        },
+        summaryKeys: ["snapshot_path"],
+        riskProfile: { mutates: "none", risk: "low", reason: "reads a local native RSVP snapshot" },
+    },
+];