@ouro.bot/cli 0.1.0-alpha.726 → 0.1.0-alpha.727

package/dist/heart/daemon/daemon.js

@@ -39,6 +39,8 @@ exports.parseOrphanPidsFromPs = parseOrphanPidsFromPs;
 exports.filterPidfilePidsToActualOrphans = filterPidfilePidsToActualOrphans;
 exports.mergeUniqueOrphanPids = mergeUniqueOrphanPids;
 exports.waitForOrphanProcessesToSettle = waitForOrphanProcessesToSettle;
+exports.assertOrphanCleanupComplete = assertOrphanCleanupComplete;
+exports.drainOrphanProcessesBeforeStartup = drainOrphanProcessesBeforeStartup;
 exports.killOrphanProcesses = killOrphanProcesses;
 exports.writePidfile = writePidfile;
 exports.handleAgentSenseTurn = handleAgentSenseTurn;
@@ -124,7 +126,8 @@ function parseOrphanPidsFromPs(psOutput, selfPid) {
             && !line.includes("bluebubbles/entry.js")
             && !line.includes("mail-entry.js")
             && !line.includes("teams-entry.js")
-            && !line.includes("a2a-entry.js"))
+            && !line.includes("a2a-entry.js")
+            && !line.includes("voice-entry.js"))
             continue;
         // Parse `<pid> <ppid> <command...>`. ps pads these with leading spaces.
         // Regex guarantees both groups are \d+ so parseInt can't produce NaN.
@@ -228,6 +231,41 @@ async function waitForOrphanProcessesToSettle(pids, deps = {}) {
     }
     return survivors;
 }
+function assertOrphanCleanupComplete(survivingPids) {
+    if (survivingPids.length === 0)
+        return;
+    const errorReason = `refusing startup while ${survivingPids.length} orphaned Ouro processes remain: ${survivingPids.join(", ")}`;
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        component: "daemon",
+        event: "daemon.orphan_cleanup_incomplete",
+        message: errorReason,
+        meta: { survivingPids },
+    });
+    throw new Error(errorReason);
+}
+const ORPHAN_CLEANUP_MAX_SIGNAL_PASSES = 8;
+async function drainOrphanProcessesBeforeStartup(socketPath = socket_client_1.DEFAULT_DAEMON_SOCKET_PATH, deps = {}) {
+    const signalOrphans = deps.signalOrphans ?? killOrphanProcesses;
+    const settleOrphans = deps.settleOrphans ?? waitForOrphanProcessesToSettle;
+    const maxSignalPasses = deps.maxSignalPasses ?? ORPHAN_CLEANUP_MAX_SIGNAL_PASSES;
+    for (let pass = 0; pass < maxSignalPasses; pass += 1) {
+        const signaledPids = signalOrphans(socketPath);
+        if (signaledPids.length === 0)
+            return;
+        const survivingPids = await settleOrphans(signaledPids);
+        assertOrphanCleanupComplete(survivingPids);
+    }
+    const errorReason = `orphan cleanup did not reach a fixed point after ${maxSignalPasses} signaling round(s)`;
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        component: "daemon",
+        event: "daemon.orphan_cleanup_not_converged",
+        message: errorReason,
+        meta: { maxSignalPasses },
+    });
+    throw new Error(errorReason);
+}
 /* v8 ignore start -- shells out to ps; covered by filterPidfilePidsToActualOrphans unit tests via injected runner @preserve */
 function runPsCheck(pids) {
     try {
@@ -305,7 +343,10 @@ function killOrphanProcesses(socketPath = socket_client_1.DEFAULT_DAEMON_SOCKET_
             const result = (0, child_process_1.execSync)("ps -eo pid,ppid,command", { encoding: "utf-8", timeout: 5000 });
             scanOrphans = parseOrphanPidsFromPs(result, process.pid);
         }
-        catch { /* ps failed — best effort */ }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            throw new Error(`could not discover orphaned Ouro processes: ${detail}`);
+        }
         const pidsToKill = mergeUniqueOrphanPids(pidfileOrphans, scanOrphans);
         if (pidsToKill.length > 0) {
             for (const pid of pidsToKill) {
@@ -325,13 +366,13 @@ function killOrphanProcesses(socketPath = socket_client_1.DEFAULT_DAEMON_SOCKET_
     }
     catch (error) {
         (0, runtime_1.emitNervesEvent)({
-            level: "warn",
+            level: "error",
             component: "daemon",
             event: "daemon.orphan_cleanup_error",
             message: "failed to clean up orphaned ouro processes",
             meta: { error: error instanceof Error ? error.message : String(error) },
         });
-        return [];
+        throw error instanceof Error ? error : new Error(String(error));
     }
 }
 /**
@@ -575,6 +616,7 @@ class OuroDaemon {
     onStopCommandComplete;
     externalEventRoot;
     rsvpHabitRunner;
+    orphanStartupDrain;
     constructor(options) {
         this.socketPath = options.socketPath;
         this.processManager = options.processManager;
@@ -589,6 +631,7 @@ class OuroDaemon {
         this.onStopCommandComplete = options.onStopCommandComplete ?? null;
         this.externalEventRoot = options.externalEventRoot ?? null;
         this.rsvpHabitRunner = options.rsvpHabitRunner;
+        this.orphanStartupDrain = options.orphanStartupDrain ?? drainOrphanProcessesBeforeStartup;
     }
     /* v8 ignore start -- default mailbox server wiring: production-only path, tests inject mailboxServerFactory stub instead. startMailboxHttpServer itself has full coverage in mailbox-http.test.ts @preserve */
     createDefaultMailboxServer() {
@@ -740,10 +783,7 @@ class OuroDaemon {
         }
         // MCP connections are lazily initialized per-agent during senseTurn
         // (daemon manages multiple agents; agent identity must be set before loading MCP config)
-        /* v8 ignore start -- orphan cleanup + pidfile: calls process management functions @preserve */
-        const killedOrphanPids = killOrphanProcesses(this.socketPath);
-        await waitForOrphanProcessesToSettle(killedOrphanPids);
-        /* v8 ignore stop */
+        await this.orphanStartupDrain(this.socketPath);
         await this.openCommandSocket();
         this.triggerAutoStartAgents();
         this.triggerAutoStartSensesWhenAgentsSettled();
@@ -1049,8 +1089,12 @@ class OuroDaemon {
             clearTimeout(this.senseAutostartTimer);
             this.senseAutostartTimer = null;
         }
-        await this.processManager.stopAll();
-        await this.senseManager?.stopAll();
+        const workerStopTasks = [Promise.resolve().then(() => this.processManager.stopAll())];
+        if (this.senseManager) {
+            workerStopTasks.push(Promise.resolve().then(() => this.senseManager.stopAll()));
+        }
+        const workerStopResults = await Promise.allSettled(workerStopTasks);
+        const workerStopFailures = workerStopResults.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
         if (this.server) {
             // DO NOT `await` server.close() here. server.close() resolves only
             // after every open connection has closed. When stop() is invoked
@@ -1113,6 +1157,19 @@ class OuroDaemon {
             });
         }
         this.socketIdentity = null;
+        if (workerStopFailures.length > 0) {
+            const errorReason = `daemon shutdown could not drain ${workerStopFailures.length} managed worker group(s)`;
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "daemon",
+                event: "daemon.worker_shutdown_error",
+                message: errorReason,
+                meta: {
+                    failures: workerStopFailures.map((error) => error instanceof Error ? error.message : /* v8 ignore next -- defensive: non-Error rejection @preserve */ String(error)),
+                },
+            });
+            throw new AggregateError(workerStopFailures, errorReason);
+        }
     }
     async handleRawPayload(raw) {
         try {
@@ -1477,8 +1534,12 @@ class OuroDaemon {
                 await this.start();
                 return { ok: true, message: "daemon started" };
             case "daemon.stop":
-                await this.stop();
-                this.onStopCommandComplete?.();
+                try {
+                    await this.stop();
+                }
+                finally {
+                    this.onStopCommandComplete?.();
+                }
                 return { ok: true, message: "daemon stopped" };
             case "daemon.restart": {
                 // Restart is "stop + let launchctl respawn." Under launchctl's KeepAlive
@@ -1494,8 +1555,12 @@ class OuroDaemon {
                         requestedBy: command.requestedBy ?? null,
                     },
                 });
-                await this.stop();
-                this.onStopCommandComplete?.();
+                try {
+                    await this.stop();
+                }
+                finally {
+                    this.onStopCommandComplete?.();
+                }
                 return {
                     ok: true,
                     message: "daemon restarting — launchctl will respawn",

package/dist/heart/daemon/process-manager.js

@@ -56,6 +56,9 @@ exports.RESPAWN_GUARD_WINDOW_MS = 10 * 60_000;
 const MAX_PENDING_IPC_MESSAGES = 20;
 class DaemonProcessManager {
     agents = new Map();
+    /** `stopAll()` is terminal for a manager instance. Once set, it fences
+     *  detached restart/start continuations until the owning daemon exits. */
+    shutdownRequested = false;
     maxRestartsPerHour;
     stabilityThresholdMs;
     initialBackoffMs;
@@ -67,6 +70,7 @@ class DaemonProcessManager {
     cooldownRecoveryMs;
     maxCooldownRetries;
     startupStaleAfterMs;
+    stopTimeoutMs;
     existsSyncFn;
     configCheckFn;
     statusWriterFn;
@@ -143,6 +147,7 @@ class DaemonProcessManager {
         this.cooldownRecoveryMs = options.cooldownRecoveryMs ?? 5 * 60 * 1_000;
         this.maxCooldownRetries = options.maxCooldownRetries ?? 3;
         this.startupStaleAfterMs = options.startupStaleAfterMs ?? 45_000;
+        this.stopTimeoutMs = options.stopTimeoutMs ?? 4_000;
         this.spawnFn = options.spawn ?? ((command, args, spawnOptions) => (0, child_process_1.spawn)(command, args, spawnOptions));
         this.now = options.now ?? (() => Date.now());
         this.setTimeoutFn = options.setTimeoutFn ?? ((cb, delay) => setTimeout(cb, delay));
@@ -169,6 +174,7 @@ class DaemonProcessManager {
                 cooldownTimer: null,
                 cooldownRetryCount: 0,
                 fastCrashCount: 0,
+                stopFailureActive: false,
                 snapshot: {
                     name: agent.name,
                     channel: agent.channel,
@@ -206,6 +212,8 @@ class DaemonProcessManager {
     }
     async startAgent(agent, options = {}) {
         const state = this.requireAgent(agent);
+        if (this.shutdownRequested)
+            return;
         if (state.process || state.startInFlight)
             return;
         const attemptId = state.startAttemptId + 1;
@@ -426,25 +434,87 @@ class DaemonProcessManager {
             return;
         }
         const child = state.process;
-        state.process = null;
-        state.snapshot.status = "stopped";
-        state.snapshot.pid = null;
-        try {
-            child.kill("SIGTERM");
-        }
-        catch {
-            (0, runtime_1.emitNervesEvent)({
-                level: "warn",
-                component: "daemon",
-                event: "daemon.agent_stop_error",
-                message: "failed to send SIGTERM to managed agent",
-                meta: { agent },
-            });
-        }
-        this.notifySnapshotChange(state.snapshot);
+        const childPid = child.pid ?? null;
+        const childPidLabel = childPid === null ? "unknown" : String(childPid);
+        await new Promise((resolve, reject) => {
+            let settled = false;
+            let timeout = null;
+            const finish = (error) => {
+                /* v8 ignore next -- defensive idempotence if an injected timer fires after cancellation @preserve */
+                if (settled)
+                    return;
+                settled = true;
+                child.removeListener("exit", onExit);
+                if (timeout !== null)
+                    this.clearTimeoutFn(timeout);
+                if (error)
+                    reject(error);
+                else
+                    resolve();
+            };
+            const onExit = () => finish();
+            child.once("exit", onExit);
+            let signalAccepted = false;
+            try {
+                signalAccepted = child.kill("SIGTERM");
+            }
+            catch {
+                const errorReason = "failed to send SIGTERM to managed agent; worker remains tracked";
+                state.stopFailureActive = true;
+                state.snapshot.errorReason = errorReason;
+                state.snapshot.fixHint = `Inspect managed worker PID ${childPidLabel} before retrying the stop or restart.`;
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "daemon",
+                    event: "daemon.agent_stop_error",
+                    message: errorReason,
+                    meta: { agent, pid: childPid },
+                });
+                this.notifySnapshotChange(state.snapshot);
+                finish(new Error(errorReason));
+                return;
+            }
+            if (!signalAccepted) {
+                const errorReason = "managed agent rejected SIGTERM; worker remains tracked";
+                state.stopFailureActive = true;
+                state.snapshot.errorReason = errorReason;
+                state.snapshot.fixHint = `Inspect managed worker PID ${childPidLabel} before retrying the stop or restart.`;
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "daemon",
+                    event: "daemon.agent_stop_error",
+                    message: errorReason,
+                    meta: { agent, pid: childPid },
+                });
+                this.notifySnapshotChange(state.snapshot);
+                finish(new Error(errorReason));
+                return;
+            }
+            if (settled)
+                return;
+            timeout = this.setTimeoutFn(() => {
+                if (settled)
+                    return;
+                const errorReason = `managed agent did not exit within ${this.stopTimeoutMs}ms; replacement was not started`;
+                state.stopFailureActive = true;
+                state.snapshot.errorReason = errorReason;
+                state.snapshot.fixHint = `Inspect managed worker PID ${childPidLabel}; retry only after that worker has exited.`;
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "daemon",
+                    event: "daemon.agent_stop_timeout",
+                    message: errorReason,
+                    meta: { agent, pid: childPid, timeoutMs: this.stopTimeoutMs },
+                });
+                this.notifySnapshotChange(state.snapshot);
+                finish(new Error(errorReason));
+            }, this.stopTimeoutMs);
+        });
     }
     async restartAgent(agent, options = {}) {
         const state = this.requireAgent(agent);
+        if (this.shutdownRequested)
+            return;
         // Respawn-loop guard: prune timestamps outside the window, then check
         // whether we've already restarted this agent too many times in it.
         const now = this.now();
@@ -528,8 +598,14 @@ class DaemonProcessManager {
         await this.startAgent(agent, options);
     }
     async stopAll() {
-        for (const state of this.agents.values()) {
-            await this.stopAgent(state.config.name);
+        this.shutdownRequested = true;
+        const states = [...this.agents.values()];
+        const results = await Promise.allSettled(states.map((state) => this.stopAgent(state.config.name)));
+        const failures = results.flatMap((result, index) => result.status === "rejected"
+            ? [{ agent: states[index].config.name, reason: result.reason }]
+            : []);
+        if (failures.length > 0) {
+            throw new AggregateError(failures.map((failure) => failure.reason), `failed to stop ${failures.length} managed worker(s): ${failures.map((failure) => failure.agent).join(", ")}`);
         }
     }
     resetAgentFailureState(agent) {
@@ -582,6 +658,7 @@ class DaemonProcessManager {
         return [...this.agents.values()].map((state) => state.snapshot);
     }
     onExit(state, child, code, signal) {
+        /* v8 ignore next -- defensive: replacement cannot start before this child's one-shot exit listener drains @preserve */
         if (state.process !== child)
             return;
         state.process = null;
@@ -590,6 +667,11 @@ class DaemonProcessManager {
         state.snapshot.pid = null;
         state.snapshot.lastExitCode = code;
         state.snapshot.lastSignal = signal;
+        if (state.stopFailureActive) {
+            state.stopFailureActive = false;
+            state.snapshot.errorReason = null;
+            state.snapshot.fixHint = null;
+        }
         const crashed = !state.stopRequested && code !== 0;
         const now = this.currentTimeMs();
         const startedAt = state.snapshot.startedAt ? Date.parse(state.snapshot.startedAt) : now;

package/dist/heart/providers/anthropic.js

@@ -104,14 +104,13 @@ function parseToolCallInput(argumentsJson) {
     }
 }
 function toAnthropicMessages(messages) {
-    let system;
+    const systemParts = [];
     const converted = [];
     for (const msg of messages) {
         if (msg.role === "system") {
-            if (!system) {
-                const text = toAnthropicTextContent(msg.content);
-                system = text || undefined;
-            }
+            const text = toAnthropicTextContent(msg.content).trim();
+            if (text)
+                systemParts.push(text);
             continue;
         }
         if (msg.role === "user") {
@@ -173,7 +172,7 @@ function toAnthropicMessages(messages) {
             });
         }
     }
-    return { system, messages: converted };
+    return { system: systemParts.length > 0 ? systemParts.join("\n\n") : undefined, messages: converted };
 }
 function toAnthropicTools(tools) {
     return tools.map((tool) => ({
@@ -231,6 +230,11 @@ function isAnthropicAuthFailure(error) {
 }
 async function streamAnthropicMessages(client, model, request) {
     const { system, messages } = toAnthropicMessages(request.messages);
+    const additionalSystemParts = request.messages
+        .filter((message) => message.role === "system")
+        .slice(1)
+        .map((message) => toAnthropicTextContent(message.content).trim())
+        .filter((text) => text.length > 0);
     const anthropicTools = toAnthropicTools(request.activeTools);
     const modelCaps = (0, model_capabilities_1.getModelCapabilities)(model);
     const maxTokens = modelCaps.maxOutputTokens ?? 16384;
@@ -255,12 +259,13 @@ async function streamAnthropicMessages(client, model, request) {
             text: preambleText + "\n\n" + request.systemPrompt.stable,
             cache_control: { type: "ephemeral" },
         };
-        if (request.systemPrompt.volatile) {
-            params.system = [stableBlock, { type: "text", text: request.systemPrompt.volatile }];
-        }
-        else {
-            params.system = [stableBlock];
-        }
+        params.system = [
+            stableBlock,
+            ...(request.systemPrompt.volatile
+                ? [{ type: "text", text: request.systemPrompt.volatile }]
+                : []),
+            ...additionalSystemParts.map((text) => ({ type: "text", text })),
+        ];
     }
     else if (system) {
         // Fallback: no structured prompt, extract from messages (legacy path)

package/dist/heart/streaming.js

@@ -496,14 +496,14 @@ function toResponsesUserContent(content) {
     return parts.length > 0 ? parts : "";
 }
 function toResponsesInput(messages) {
-    let instructions = "";
+    const instructionParts = [];
     const input = [];
     for (const msg of messages) {
         if (msg.role === "system") {
-            if (!instructions) {
-                const sys = msg;
-                instructions = (typeof sys.content === "string" ? sys.content : "") || "";
-            }
+            const sys = msg;
+            const content = (typeof sys.content === "string" ? sys.content : "").trim();
+            if (content)
+                instructionParts.push(content);
             continue;
         }
         if (msg.role === "user") {
@@ -551,7 +551,7 @@ function toResponsesInput(messages) {
             continue;
         }
     }
-    return { instructions, input };
+    return { instructions: instructionParts.join("\n\n"), input };
 }
 function toResponsesTools(ccTools) {
     return ccTools.map((t) => ({

package/dist/mind/prompt-budget.js

@@ -3,6 +3,7 @@ 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.assessRequiredPromptEvidenceBudget = assessRequiredPromptEvidenceBudget;
 exports.applyPromptBudget = applyPromptBudget;
 const runtime_1 = require("../nerves/runtime");
 exports.PROMPT_BUDGET_POLICY_VERSION = "prompt-budget/v1";
@@ -89,6 +90,42 @@ function itemTokens(item) {
 function cloneMessage(message) {
     return { ...message };
 }
+function requiredMessagesByIdentity(input) {
+    const evidence = input.requiredPromptEvidence;
+    if (!evidence)
+        return [];
+    const current = evidence.currentUserMessage;
+    if (current.role !== "user") {
+        throw new Error("required current user message must have role=user");
+    }
+    const currentMatches = input.messages.filter((message) => message === current);
+    if (currentMatches.length !== 1) {
+        throw new Error(currentMatches.length === 0
+            ? "required current user message is not present by identity"
+            : "required current user message must appear exactly once by identity");
+    }
+    const predecessor = evidence.verifiedPredecessorMessage;
+    if (predecessor) {
+        if (predecessor === current)
+            throw new Error("required predecessor and current user message must be distinct objects");
+        if (predecessor.role !== "system") {
+            throw new Error("required verified predecessor message must have role=system");
+        }
+        const predecessorMatches = input.messages.filter((message) => message === predecessor);
+        if (predecessorMatches.length !== 1) {
+            throw new Error(predecessorMatches.length === 0
+                ? "required verified predecessor message is not present by identity"
+                : "required verified predecessor message must appear exactly once by identity");
+        }
+        if (input.messages.indexOf(predecessor) !== input.messages.indexOf(current) - 1) {
+            throw new Error("required verified predecessor message must be immediately before the current user message");
+        }
+    }
+    return input.messages.filter((message) => message === current || message === predecessor);
+}
+function cloneUnlessRequired(message, requiredMessages) {
+    return requiredMessages.has(message) ? message : cloneMessage(message);
+}
 function messageText(message) {
     return typeof message.content === "string" ? message.content : "";
 }
@@ -197,11 +234,35 @@ function nonSystemSourceFor(messages) {
         return "diagnostics";
     return "recent-session-tail";
 }
-function buildPromptBudgetItems(messages) {
+function buildPromptBudgetItems(messages, requiredPromptEvidence) {
     const rawItems = [];
     let index = 0;
     while (index < messages.length) {
         const message = messages[index];
+        if (message === requiredPromptEvidence?.currentUserMessage) {
+            rawItems.push({
+                id: `required:${index}:current`,
+                priority: 1,
+                source: "current-user-message",
+                messages: [message],
+                originalMessageCount: 1,
+                required: "current-user",
+            });
+            index += 1;
+            continue;
+        }
+        if (message === requiredPromptEvidence?.verifiedPredecessorMessage) {
+            rawItems.push({
+                id: `required:${index}:predecessor`,
+                priority: 1,
+                source: "required-current-turn-state",
+                messages: [message],
+                originalMessageCount: 1,
+                required: "verified-predecessor",
+            });
+            index += 1;
+            continue;
+        }
         if (message.role === "system") {
             rawItems.push(...systemItems(message, index));
             index += 1;
@@ -236,6 +297,8 @@ function buildPromptBudgetItems(messages) {
     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 (item.required)
+            return item;
         if (itemIndex === lastUserItemIndex) {
             return { ...item, priority: 1, source: "current-user-message" };
         }
@@ -254,7 +317,7 @@ function buildPromptBudgetItems(messages) {
     });
 }
 function flattenItems(items) {
-    return items.flatMap((item) => item.messages.map(cloneMessage));
+    return items.flatMap((item) => item.messages.map((message) => item.required ? message : cloneMessage(message)));
 }
 function budgetFor(input) {
     const contextWindowTokens = typeof input.contextWindowTokens === "number" && Number.isFinite(input.contextWindowTokens) && input.contextWindowTokens > 0
@@ -273,6 +336,19 @@ function budgetFor(input) {
         inputTokenLimit: Math.max(0, contextWindowTokens - outputReserveTokens - protocolReserveTokens),
     };
 }
+function assessRequiredPromptEvidenceBudget(input) {
+    const budget = budgetFor(input);
+    const messages = requiredMessagesByIdentity(input);
+    const estimatedTokens = estimatePromptBudgetTokens(messages);
+    return {
+        status: messages.length > 0 && estimatedTokens > budget.inputTokenLimit
+            ? "required_evidence_over_budget"
+            : "within_budget",
+        messages,
+        estimatedTokens,
+        budget,
+    };
+}
 function totalItemTokens(items) {
     return estimatePromptBudgetTokens(flattenItems(items));
 }
@@ -304,15 +380,38 @@ function emitPromptBudgetEvent(result) {
     });
 }
 function applyPromptBudget(input) {
-    const budget = budgetFor(input);
+    const requiredAssessment = assessRequiredPromptEvidenceBudget(input);
+    const budget = requiredAssessment.budget;
     const estimatedBeforeTokens = estimatePromptBudgetTokens(input.messages);
     const truncations = [];
+    const requiredMessages = requiredAssessment.messages;
+    const requiredMessageSet = new Set(requiredMessages);
     let droppedMessages = 0;
+    const requiredTokens = requiredAssessment.estimatedTokens;
+    if (requiredAssessment.status === "required_evidence_over_budget") {
+        droppedMessages = input.messages.length - requiredMessages.length;
+        const result = {
+            policyVersion: exports.PROMPT_BUDGET_POLICY_VERSION,
+            status: "required_evidence_over_budget",
+            messages: requiredMessages,
+            budget,
+            stats: {
+                estimatedBeforeTokens,
+                estimatedAfterTokens: requiredTokens,
+                originalMessages: input.messages.length,
+                finalMessages: requiredMessages.length,
+                droppedMessages,
+                truncations,
+            },
+        };
+        emitPromptBudgetEvent(result);
+        return result;
+    }
     if (estimatedBeforeTokens <= budget.inputTokenLimit) {
         const result = {
             policyVersion: exports.PROMPT_BUDGET_POLICY_VERSION,
             status: "within_budget",
-            messages: input.messages.map(cloneMessage),
+            messages: input.messages.map((message) => cloneUnlessRequired(message, requiredMessageSet)),
             budget,
             stats: {
                 estimatedBeforeTokens,
@@ -326,7 +425,7 @@ function applyPromptBudget(input) {
         emitPromptBudgetEvent(result);
         return result;
     }
-    let items = buildPromptBudgetItems(input.messages);
+    let items = buildPromptBudgetItems(input.messages, input.requiredPromptEvidence);
     for (const priority of [8, 7, 6, 5, 4, 3]) {
         if (totalItemTokens(items) <= budget.inputTokenLimit)
             break;

package/dist/repertoire/tools.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.surfaceToolDef = exports.speakTool = exports.restTool = exports.ponderTool = exports.observeTool = exports.settleTool = exports.tools = void 0;
 exports.resetMcpDefinitions = resetMcpDefinitions;
 exports.getToolsForChannel = getToolsForChannel;
-exports.getRestrictedReactionFeedbackTools = getRestrictedReactionFeedbackTools;
 exports.resolveToolDefinition = resolveToolDefinition;
 exports.shellRiskProfile = shellRiskProfile;
 exports.riskProfileForTool = riskProfileForTool;
@@ -127,15 +126,6 @@ function getToolsForChannel(capabilities, toolPreferences, _context, providerCap
     }
     return filterByCapability(result, providerCapabilities);
 }
-/**
- * The complete provider-facing tool surface for trusted reaction feedback.
- * Keep these schemas sourced from the normal registry so restricted turns
- * cannot drift onto lookalike definitions or inherit channel/MCP tools.
- */
-function getRestrictedReactionFeedbackTools() {
-    const orientationGetTool = tools_base_1.baseToolDefinitions.find((definition) => definition.tool.function.name === "orientation_get").tool;
-    return [tools_base_1.settleTool, tools_base_1.observeTool, orientationGetTool];
-}
 // Look up a tool definition from the live combined registry (native + MCP).
 // The base registry is intentionally consulted at call time so tests and
 // runtime extensions cannot leave execution metadata behind a stale snapshot.