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

package/dist/senses/private-runtime-worker.js

@@ -51,6 +51,94 @@ const friends_1 = require("@ouro.bot/friends");
 const tools_base_1 = require("../repertoire/tools-base");
 const tools_surface_1 = require("../repertoire/tools-surface");
 const tools_1 = require("../repertoire/tools");
+const habit_policy_1 = require("../rsvp/habit-policy");
+const run_ledger_1 = require("../heart/run-ledger");
+const autonomy_budget_1 = require("../heart/autonomy-budget");
+function isUsageData(value) {
+    const usage = value;
+    return !!usage
+        && typeof usage.input_tokens === "number"
+        && typeof usage.output_tokens === "number"
+        && typeof usage.total_tokens === "number";
+}
+function extractUsageFromHabitResults(results) {
+    const aggregate = {
+        input_tokens: 0,
+        output_tokens: 0,
+        reasoning_tokens: 0,
+        total_tokens: 0,
+    };
+    let found = false;
+    for (const result of results) {
+        if (!result || typeof result !== "object")
+            continue;
+        const usage = result.usage;
+        if (!isUsageData(usage))
+            continue;
+        found = true;
+        aggregate.input_tokens += usage.input_tokens;
+        aggregate.output_tokens += usage.output_tokens;
+        aggregate.reasoning_tokens += typeof usage.reasoning_tokens === "number" ? usage.reasoning_tokens : 0;
+        aggregate.total_tokens += usage.total_tokens;
+    }
+    return found ? aggregate : undefined;
+}
+function habitRunLedgerBase(habitRun) {
+    const target = {
+        habitName: habitRun.habit.name,
+        runId: habitRun.runId,
+        trigger: habitRun.trigger,
+        operationId: habitRun.operationId,
+    };
+    return {
+        agent: (0, identity_1.getAgentName)(),
+        triggerType: "habit",
+        sourceKind: "private-runtime",
+        senseOrHabit: habitRun.habit.name,
+        startedAt: habitRun.startedAt,
+        target,
+        idempotencyScope: target,
+        provider: "unknown",
+        model: "unknown",
+        sessionRef: {
+            channel: "inner",
+            keyHash: (0, run_ledger_1.runLedgerHash)({ habitName: habitRun.habit.name, runId: habitRun.runId }),
+        },
+    };
+}
+function recordHabitRunLedger(habitRun, lifecycle, endedAt) {
+    const usage = extractUsageFromHabitResults(habitRun.results);
+    (0, run_ledger_1.appendRunLedgerRecordNonFatal)(habitRun.agentRoot, (0, run_ledger_1.createRunLedgerRecord)({
+        ...habitRunLedgerBase(habitRun),
+        lifecycle,
+        ...(endedAt ? { endedAt } : {}),
+        ...(lifecycle === "completed" || lifecycle === "error"
+            ? { usage: (0, run_ledger_1.usageMetadataFromUsageData)(usage, usage ? "provider" : "none") }
+            : {}),
+    }));
+}
+function reserveHabitAutonomyBudget(habitRun, nowIso) {
+    const target = {
+        habitName: habitRun.habit.name,
+        runId: habitRun.runId,
+        trigger: habitRun.trigger,
+        operationId: habitRun.operationId,
+    };
+    if (habitRun.rsvpPolicy) {
+        target.rsvpSnapshotRef = habitRun.rsvpPolicy.snapshotRef;
+        target.rsvpBudgetRef = habitRun.rsvpPolicy.budgetRef;
+        target.rsvpIdempotencyRef = habitRun.rsvpPolicy.idempotencyRef;
+    }
+    return (0, autonomy_budget_1.reserveAutonomyBudget)(habitRun.agentRoot, {
+        agent: (0, identity_1.getAgentName)(),
+        triggerType: "habit",
+        sourceKind: "private-runtime",
+        senseOrHabit: habitRun.habit.name,
+        target,
+        idempotencyKey: `habit:${habitRun.habit.name}:${habitRun.runId}`,
+        now: nowIso,
+    });
+}
 /**
  * Cap on consecutive `instinct` follow-on turns triggered by `hasPendingWork()`
  * with no externally-queued work in between. Without this cap, a turn that
@@ -208,13 +296,20 @@ async function prepareHabitRun(habitName, trigger, startedAt) {
     const agentRoot = (0, identity_1.getAgentRoot)();
     const errors = [];
     const habit = (0, habit_runtime_state_1.applyHabitRuntimeState)(agentRoot, readHabitForRun(agentRoot, habitName, errors));
+    const blockedReason = (0, habit_policy_1.isRsvpHabitName)(habitName) && !habit.rsvp
+        ? "RSVP habit metadata is required before private runtime execution"
+        : null;
+    if (blockedReason && !errors.includes(blockedReason))
+        errors.push(blockedReason);
     const runId = (0, flight_recorder_1.createHabitRunId)(habitName, new Date(startedAt));
     const operationId = habit.continuity.mode === "stateful" ? `habit:${habit.name}` : null;
     const priorSessionSummary = readPriorSessionSummary(agentRoot, operationId);
     const paths = (0, habit_session_1.createHabitSessionPaths)(agentRoot, runId, habit.name);
     const friendStore = new friends_1.FileFriendStore(path.join(agentRoot, "friends"));
     const permissionEnvelope = await (0, habit_session_1.normalizeHabitPermissionEnvelope)(habit, { agentRoot, friendStore });
-    const toolPolicy = (0, habit_session_1.filterHabitToolsForEnvelope)([...tools_base_1.baseToolDefinitions, tools_surface_1.surfaceToolDefinition], habit.tools ?? null, permissionEnvelope, riskProfileForHabitPolicy);
+    const rsvpPolicy = habit.rsvp ? (0, habit_policy_1.rsvpHabitRuntimePolicy)(habit.rsvp) : undefined;
+    const requestedTools = blockedReason ? [] : habit.rsvp ? [...habit_policy_1.RSVP_HABIT_ALLOWED_TOOLS] : habit.tools ?? null;
+    const toolPolicy = (0, habit_session_1.filterHabitToolsForEnvelope)([...tools_base_1.baseToolDefinitions, tools_surface_1.surfaceToolDefinition], requestedTools, permissionEnvelope, riskProfileForHabitPolicy);
     return {
         agentRoot,
         habit,
@@ -226,6 +321,8 @@ async function prepareHabitRun(habitName, trigger, startedAt) {
         paths,
         permissionEnvelope,
         toolPolicy,
+        ...(rsvpPolicy ? { rsvpPolicy } : {}),
+        ...(blockedReason ? { blockedReason } : {}),
         friendStore,
         results: [],
         errors,
@@ -265,8 +362,17 @@ function createPrivateRuntimeWorker(runTurn = (options) => (0, private_runtime_1
     const queue = [];
     const lastFireByHabit = new Map();
     const recentHabitFires = [];
+    const startedHabitLedgerRunIds = new Set();
     let heartbeatOkRestedAt = null;
+    function recordHabitStartIfNeeded(habitRun) {
+        if (startedHabitLedgerRunIds.has(habitRun.runId))
+            return;
+        recordHabitRunLedger(habitRun, "started");
+        startedHabitLedgerRunIds.add(habitRun.runId);
+    }
     function recordHabitCompletion(habitRun, endedAt = habitRun.startedAt) {
+        recordHabitStartIfNeeded(habitRun);
+        recordHabitRunLedger(habitRun, habitRun.errors.length > 0 ? "error" : "completed", endedAt);
         (0, habit_session_1.completeHabitRun)({
             agentRoot: habitRun.agentRoot,
             habit: habitRun.habit,
@@ -390,38 +496,67 @@ function createPrivateRuntimeWorker(runTurn = (options) => (0, private_runtime_1
                     clearHeartbeatRestShield();
                 }
                 let turnResult;
+                let blockedAutonomyTurn = false;
                 try {
-                    const turnOptions = {
-                        reason: nextReason,
-                        taskId: nextTaskId,
-                        habitName: nextHabitName,
-                        awaitName: nextAwaitName,
-                        ...(nextPrivateTurnDecision ? { privateTurnDecision: nextPrivateTurnDecision } : {}),
-                        ...(currentHabitRun
-                            ? {
-                                trigger: currentHabitRun.trigger,
-                                preparedHabit: {
-                                    runId: currentHabitRun.runId,
+                    const turnStartedAt = new Date(nowSource()).toISOString();
+                    const autonomyDecision = currentHabitRun && !currentHabitRun.blockedReason
+                        ? reserveHabitAutonomyBudget(currentHabitRun, turnStartedAt)
+                        : null;
+                    if (currentHabitRun)
+                        recordHabitStartIfNeeded(currentHabitRun);
+                    if (currentHabitRun?.blockedReason) {
+                        blockedAutonomyTurn = true;
+                        turnResult = {
+                            turnOutcome: "blocked",
+                            reason: currentHabitRun.blockedReason,
+                        };
+                        clearHeartbeatRestShield();
+                    }
+                    else if (autonomyDecision && !autonomyDecision.allowed) {
+                        blockedAutonomyTurn = true;
+                        const reason = `autonomy budget blocked: ${autonomyDecision.reason}`;
+                        turnErrors.push(reason);
+                        turnResult = {
+                            turnOutcome: "blocked",
+                            reason,
+                            autonomyReceiptId: autonomyDecision.receiptId,
+                        };
+                        clearHeartbeatRestShield();
+                    }
+                    else {
+                        const turnOptions = {
+                            reason: nextReason,
+                            taskId: nextTaskId,
+                            habitName: nextHabitName,
+                            awaitName: nextAwaitName,
+                            ...(nextPrivateTurnDecision ? { privateTurnDecision: nextPrivateTurnDecision } : {}),
+                            ...(currentHabitRun
+                                ? {
                                     trigger: currentHabitRun.trigger,
-                                    operationId: currentHabitRun.operationId,
-                                    habit: currentHabitRun.habit,
-                                    priorSessionSummary: currentHabitRun.priorSessionSummary,
-                                },
-                                habitSession: {
-                                    runId: currentHabitRun.runId,
-                                    sessionPath: currentHabitRun.paths.sessionPath,
-                                    pendingDir: currentHabitRun.paths.pendingDir,
-                                    permissionEnvelope: currentHabitRun.permissionEnvelope,
-                                    toolPolicy: currentHabitRun.toolPolicy,
-                                    friendStore: currentHabitRun.friendStore,
-                                    recordProducedRef: (ref) => { currentHabitRun.producedRefs.push(ref); },
-                                    recordSurfaceAttempt: (attempt) => { currentHabitRun.surfaceAttempts.push(attempt); },
-                                    recordError: (error) => { currentHabitRun.errors.push(error); },
-                                },
-                            }
-                            : {}),
-                    };
-                    turnResult = await runTurn(turnOptions);
+                                    preparedHabit: {
+                                        runId: currentHabitRun.runId,
+                                        trigger: currentHabitRun.trigger,
+                                        operationId: currentHabitRun.operationId,
+                                        habit: currentHabitRun.habit,
+                                        priorSessionSummary: currentHabitRun.priorSessionSummary,
+                                    },
+                                    habitSession: {
+                                        runId: currentHabitRun.runId,
+                                        sessionPath: currentHabitRun.paths.sessionPath,
+                                        pendingDir: currentHabitRun.paths.pendingDir,
+                                        permissionEnvelope: currentHabitRun.permissionEnvelope,
+                                        toolPolicy: currentHabitRun.toolPolicy,
+                                        ...(currentHabitRun.rsvpPolicy ? { rsvpPolicy: currentHabitRun.rsvpPolicy } : {}),
+                                        friendStore: currentHabitRun.friendStore,
+                                        recordProducedRef: (ref) => { currentHabitRun.producedRefs.push(ref); },
+                                        recordSurfaceAttempt: (attempt) => { currentHabitRun.surfaceAttempts.push(attempt); },
+                                        recordError: (error) => { currentHabitRun.errors.push(error); },
+                                    },
+                                }
+                                : {}),
+                        };
+                        turnResult = await runTurn(turnOptions);
+                    }
                 }
                 catch (error) {
                     clearHeartbeatRestShield();
@@ -466,6 +601,10 @@ function createPrivateRuntimeWorker(runTurn = (options) => (0, private_runtime_1
                     consecutiveInstinctTurns = nextReason === "instinct" ? consecutiveInstinctTurns + 1 : 0;
                     continue runLoop;
                 }
+                if (blockedAutonomyTurn) {
+                    finalizeCurrentHabitRun();
+                    break;
+                }
                 // Then check hasPendingWork fallback. This is the loop site: any
                 // tool that writes to the private-runtime pending dir during a turn
                 // would cause hasPendingWork() to be true here, producing a

package/dist/senses/private-runtime.js

@@ -77,6 +77,7 @@ const await_runtime_state_1 = require("../heart/awaiting/await-runtime-state");
 const habit_parser_1 = require("../heart/habits/habit-parser");
 const habit_runtime_state_1 = require("../heart/habits/habit-runtime-state");
 const cadence_1 = require("../heart/daemon/cadence");
+const habit_policy_1 = require("../rsvp/habit-policy");
 const daemon_health_1 = require("../heart/daemon/daemon-health");
 const flight_recorder_1 = require("../arc/flight-recorder");
 const desk_section_1 = require("../mind/desk-section");
@@ -863,6 +864,7 @@ async function runPrivateRuntimeTurn(options) {
                 const habitName = options.habitName;
                 const habitFilePath = path.join(agentRoot, "habits", `${habitName}.md`);
                 const preparedHabit = options.preparedHabit?.habit.name === habitName ? options.preparedHabit.habit : null;
+                const rsvpHabit = (0, habit_policy_1.isRsvpHabitName)(habitName);
                 // Read and parse the habit file
                 let habitBody;
                 let habitTitle = habitName;
@@ -870,6 +872,9 @@ async function runPrivateRuntimeTurn(options) {
                 let habitOrigin = null;
                 let habitSurface = { family: true, originator: true, extra: [] };
                 if (preparedHabit) {
+                    if (rsvpHabit && !preparedHabit.rsvp) {
+                        throw new Error(`RSVP habit metadata is required before private runtime execution: ${habitName}`);
+                    }
                     habitBody = preparedHabit.body || undefined;
                     habitTitle = preparedHabit.title || habitName;
                     habitLastRun = preparedHabit.lastRun;
@@ -881,6 +886,9 @@ async function runPrivateRuntimeTurn(options) {
                     try {
                         const habitContent = fs.readFileSync(habitFilePath, "utf-8");
                         const parsed = (0, habit_runtime_state_1.applyHabitRuntimeState)(agentRoot, (0, habit_parser_1.parseHabitFile)(habitContent, habitFilePath));
+                        if (rsvpHabit && !parsed.rsvp) {
+                            throw new Error(`RSVP habit metadata is required before private runtime execution: ${habitName}`);
+                        }
                         habitBody = parsed.body || undefined;
                         habitTitle = parsed.title || habitName;
                         habitLastRun = parsed.lastRun;
@@ -888,7 +896,11 @@ async function runPrivateRuntimeTurn(options) {
                         habitOrigin = parsed.origin;
                         habitSurface = parsed.surface;
                     }
-                    catch {
+                    catch (error) {
+                        if (rsvpHabit) {
+                            const reason = error instanceof Error ? error.message : String(error);
+                            throw new Error(`RSVP habit metadata is required before private runtime execution: ${reason}`);
+                        }
                         // Habit file missing or unreadable
                     }
                 }

package/dist/senses/voice/twilio-phone.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_TWILIO_MEDIA_MAX_UTTERANCE_MS = exports.DEFAULT_TWILIO_MEDIA_MIN_SPEECH_MS = exports.DEFAULT_TWILIO_MEDIA_SILENCE_END_MS = exports.DEFAULT_TWILIO_MEDIA_SPEECH_RMS_THRESHOLD = exports.DEFAULT_TWILIO_PHONE_TRANSPORT_MODE = exports.DEFAULT_TWILIO_PHONE_PLAYBACK_MODE = exports.TWILIO_PHONE_WEBHOOK_BASE_PATH = exports.DEFAULT_TWILIO_GREETING_PREBUFFER_MS = exports.DEFAULT_TWILIO_RECORD_MAX_LENGTH_SECONDS = exports.DEFAULT_TWILIO_RECORD_TIMEOUT_SECONDS = exports.DEFAULT_TWILIO_PHONE_PORT = exports.normalizeTwilioE164PhoneNumber = void 0;
+exports.resolveTwilioPhoneAgentRoot = resolveTwilioPhoneAgentRoot;
 exports.normalizeTwilioPhoneBasePath = normalizeTwilioPhoneBasePath;
 exports.normalizeTwilioPhonePlaybackMode = normalizeTwilioPhonePlaybackMode;
 exports.normalizeTwilioPhoneTransportMode = normalizeTwilioPhoneTransportMode;
@@ -92,6 +93,9 @@ exports.DEFAULT_TWILIO_MEDIA_MIN_SPEECH_MS = 120;
 exports.DEFAULT_TWILIO_MEDIA_MAX_UTTERANCE_MS = 15_000;
 const TWILIO_MEDIA_HANGUP_FALLBACK_MS = 10_000;
 const TWILIO_STREAM_FAILURE_SILENCE_MP3 = Buffer.from("SUQzBAAAAAAAIlRTU0UAAAAOAAADTGF2ZjYyLjMuMTAwAAAAAAAAAAAAAAD/+0DAAAAAAAAAAAAAAAAAAAAAAABJbmZvAAAADwAAAAsAAAUuADc3Nzc3Nzc3N0tLS0tLS0tLS19fX19fX19fX3Nzc3Nzc3Nzc4eHh4eHh4eHh5ubm5ubm5ubm6+vr6+vr6+vr8PDw8PDw8PDw9fX19fX19fX1+vr6+vr6+vr6////////////wAAAABMYXZjNjIuMTEAAAAAAAAAAAAAAAAkBC8AAAAAAAAFLpJQTFMAAAAAAP/7EMQAA8AAAaQAAAAgAAA0gAAABExBTUUzLjEwMFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVMQU1FMy4xMDBVVVVV//sQxCmDwAABpAAAACAAADSAAAAEVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVUxBTUUzLjEwMFVVVVX/+xDEUwPAAAGkAAAAIAAANIAAAARVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVTEFNRTMuMTAwVVVVVf/7EMR8g8AAAaQAAAAgAAA0gAAABFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVMQU1FMy4xMDBVVVVV//sQxKYDwAABpAAAACAAADSAAAAEVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVUxBTUUzLjEwMFVVVVX/+xDEz4PAAAGkAAAAIAAANIAAAARVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVf/7EMTWA8AAAaQAAAAgAAA0gAAABFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV//sQxNYDwAABpAAAACAAADSAAAAEVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVX/+xDE1gPAAAGkAAAAIAAANIAAAARVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVf/7EMTWA8AAAaQAAAAgAAA0gAAABFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV//sQxNYDwAABpAAAACAAADSAAAAEVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVU=", "base64");
+function resolveTwilioPhoneAgentRoot(options) {
+    return options.agentRoot ?? (0, identity_1.getAgentRoot)(options.agentName);
+}
 function bodyText(body) {
     if (body === undefined)
         return "";
@@ -356,7 +360,7 @@ function voiceFriendId(options, from, callSid) {
     return options.defaultFriendId?.trim() || friendIdFromCaller(from, callSid);
 }
 async function resolveVoiceFriendContext(options, input) {
-    const agentRoot = options.agentRoot ?? (0, identity_1.getAgentRoot)(options.agentName);
+    const agentRoot = resolveTwilioPhoneAgentRoot(options);
     const friendStore = new friends_1.FileFriendStore(path.join(agentRoot, "friends"));
     const explicitFriendId = input.friendId?.trim();
     if (explicitFriendId) {
@@ -1047,7 +1051,7 @@ class TwilioMediaStreamSession {
     }
     async playPreparedAudio(request) {
         const prepared = await (0, audio_playback_1.prepareVoiceCallAudio)(request, {
-            agentRoot: this.options.agentRoot ?? (0, identity_1.getAgentRoot)(this.options.agentName),
+            agentRoot: resolveTwilioPhoneAgentRoot(this.options),
         });
         const generation = this.startPlayback();
         for (let offset = 0; offset < prepared.audio.byteLength; offset += 160) {
@@ -1793,7 +1797,7 @@ class TwilioOpenAIRealtimeMediaStreamSession {
     }
     async buildInstructions() {
         (0, identity_1.setAgentName)(this.options.agentName);
-        const agentRoot = this.options.agentRoot ?? (0, identity_1.getAgentRoot)(this.options.agentName);
+        const agentRoot = resolveTwilioPhoneAgentRoot(this.options);
         const sessionDir = path.join(agentRoot, "state", "sessions", this.friendId, "voice");
         await fs.mkdir(sessionDir, { recursive: true });
         this.sessionPath = path.join(sessionDir, `${(0, config_1.sanitizeKey)(this.sessionKey)}.json`);
@@ -2471,7 +2475,7 @@ class TwilioOpenAIRealtimeMediaStreamSession {
             throw new Error("voice call media stream is not ready");
         }
         const prepared = await (0, audio_playback_1.prepareVoiceCallAudio)(request, {
-            agentRoot: this.options.agentRoot ?? (0, identity_1.getAgentRoot)(this.options.agentName),
+            agentRoot: resolveTwilioPhoneAgentRoot(this.options),
         });
         this.playbackMarks.clear();
         this.playbackState = undefined;
@@ -2860,7 +2864,7 @@ class OpenAISipPhoneSession {
     }
     async buildInstructions() {
         (0, identity_1.setAgentName)(this.options.agentName);
-        const agentRoot = this.options.agentRoot ?? (0, identity_1.getAgentRoot)(this.options.agentName);
+        const agentRoot = resolveTwilioPhoneAgentRoot(this.options);
         const sessionDir = path.join(agentRoot, "state", "sessions", this.friendId, "voice");
         await fs.mkdir(sessionDir, { recursive: true });
         this.sessionPath = path.join(sessionDir, `${(0, config_1.sanitizeKey)(this.sessionKey)}.json`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.696",
+  "version": "0.1.0-alpha.697",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",