@ouro.bot/cli 0.1.0-alpha.14 → 0.1.0-alpha.141

package/dist/senses/contextual-heartbeat.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildContextualHeartbeat = buildContextualHeartbeat;
+const runtime_1 = require("../nerves/runtime");
+const STALE_THRESHOLD_MS = 30 * 60 * 1000; // 30 minutes
+const MAX_JOURNAL_FILES = 10;
+function formatElapsed(ms) {
+    const minutes = Math.floor(ms / 60000);
+    if (minutes < 60) {
+        return `${minutes} ${minutes === 1 ? "minute" : "minutes"}`;
+    }
+    const hours = Math.floor(minutes / 60);
+    return `${hours} ${hours === 1 ? "hour" : "hours"}`;
+}
+function formatRelativeTime(nowMs, mtimeMs) {
+    const diffMs = nowMs - mtimeMs;
+    const minutes = Math.floor(diffMs / 60000);
+    if (minutes < 1)
+        return "just now";
+    if (minutes < 60)
+        return `${minutes} ${minutes === 1 ? "minute" : "minutes"} ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours} ${hours === 1 ? "hour" : "hours"} ago`;
+    const days = Math.floor(hours / 24);
+    return `${days} ${days === 1 ? "day" : "days"} ago`;
+}
+function buildContextualHeartbeat(options) {
+    const { lastCompletedAt, pendingObligations, lastSurfaceAt, checkpoint, now, readJournalDir, } = options;
+    const nowDate = now();
+    const nowMs = nowDate.getTime();
+    const journalFiles = readJournalDir();
+    // Cold start: no journal files and no runtime state
+    if (journalFiles.length === 0 && !lastCompletedAt) {
+        const lines = ["...time passing. anything stirring?"];
+        if (checkpoint) {
+            lines.push(`\nlast i remember: ${checkpoint}`);
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.contextual_heartbeat_built",
+            message: "contextual heartbeat built (cold start)",
+            meta: { coldStart: true },
+        });
+        return lines.join("\n");
+    }
+    const sections = [];
+    // Elapsed time since last turn
+    if (lastCompletedAt) {
+        const lastMs = new Date(lastCompletedAt).getTime();
+        const elapsed = nowMs - lastMs;
+        sections.push(`it's been ${formatElapsed(elapsed)} since your last turn.`);
+    }
+    // Pending attention count
+    if (pendingObligations.length > 0) {
+        const count = pendingObligations.length;
+        sections.push(`you're holding ${count} ${count === 1 ? "thought" : "thoughts"}.`);
+    }
+    // Journal index
+    if (journalFiles.length > 0) {
+        const sorted = [...journalFiles].sort((a, b) => b.mtime - a.mtime).slice(0, MAX_JOURNAL_FILES);
+        const indexLines = ["## journal"];
+        for (const file of sorted) {
+            const ago = formatRelativeTime(nowMs, file.mtime);
+            const previewClause = file.preview ? ` — ${file.preview}` : "";
+            indexLines.push(`- ${file.name} (${ago})${previewClause}`);
+        }
+        sections.push(indexLines.join("\n"));
+    }
+    // Journal entries since last surface
+    if (lastSurfaceAt && journalFiles.length > 0) {
+        const surfaceMs = new Date(lastSurfaceAt).getTime();
+        const entriesSinceSurface = journalFiles.filter((f) => f.mtime > surfaceMs).length;
+        if (entriesSinceSurface > 0) {
+            const surfaceElapsed = formatElapsed(nowMs - surfaceMs);
+            sections.push(`${entriesSinceSurface} journal ${entriesSinceSurface === 1 ? "entry" : "entries"} since you last surfaced, ${surfaceElapsed} ago.`);
+        }
+    }
+    // Stale obligation alerts
+    const staleObligations = pendingObligations.filter((o) => o.staleness >= STALE_THRESHOLD_MS);
+    if (staleObligations.length > 0) {
+        for (const obligation of staleObligations) {
+            sections.push(`this has been sitting for ${formatElapsed(obligation.staleness)}: ${obligation.content}`);
+        }
+    }
+    // Checkpoint
+    if (checkpoint) {
+        sections.push(`last i remember: ${checkpoint}`);
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.contextual_heartbeat_built",
+        message: "contextual heartbeat built",
+        meta: {
+            hasJournal: journalFiles.length > 0,
+            hasLastCompleted: !!lastCompletedAt,
+            obligationCount: pendingObligations.length,
+            staleCount: staleObligations.length,
+        },
+    });
+    return sections.join("\n\n");
+}

package/dist/senses/continuity.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeContinuityClauses = normalizeContinuityClauses;
+exports.resolveMustResolveBeforeHandoff = resolveMustResolveBeforeHandoff;
+exports.classifySteeringFollowUpEffect = classifySteeringFollowUpEffect;
+const runtime_1 = require("../nerves/runtime");
+const NO_HANDOFF_CLAUSES = new Set([
+    "dont return control until complete or blocked",
+    "do not return control until complete or blocked",
+    "dont hand back control until complete or blocked",
+    "do not hand back control until complete or blocked",
+    "keep going until youre done",
+    "keep going until you are done",
+    "keep working until youre done",
+    "keep working until you are done",
+    "dont stop until youre done",
+    "do not stop until youre done",
+    "only come back if blocked",
+    "only return if blocked",
+    "only respond if blocked",
+    "work autonomously on this",
+    "work on this autonomously",
+    "handle this autonomously",
+]);
+const CANCEL_SUPERSEDE_CLAUSES = new Set([
+    "stop",
+    "cancel that",
+    "cancel this",
+    "never mind",
+    "nevermind",
+    "forget it",
+    "ignore that",
+    "ignore this",
+    "hold off",
+    "ill take it from here",
+    "i will take it from here",
+    "lets do something else",
+    "stop working on that",
+    "stop working on this",
+    "dont do that",
+    "do not do that",
+]);
+function normalizeContinuityClauses(text) {
+    return text
+        .toLowerCase()
+        .split(/[\n.!?;]+/)
+        .map((clause) => clause.replace(/[^a-z\s]/g, "").replace(/\s+/g, " ").trim())
+        .filter(Boolean);
+}
+function resolveMustResolveBeforeHandoff(initialValue, ingressTexts) {
+    let current = initialValue;
+    for (const text of ingressTexts ?? []) {
+        for (const clause of normalizeContinuityClauses(text)) {
+            if (CANCEL_SUPERSEDE_CLAUSES.has(clause)) {
+                current = false;
+                continue;
+            }
+            if (NO_HANDOFF_CLAUSES.has(clause)) {
+                current = true;
+            }
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.continuity_state_resolved",
+        message: "resolved continuity handoff state from ingress text",
+        meta: {
+            initialValue,
+            finalValue: current,
+            ingressCount: ingressTexts?.length ?? 0,
+        },
+    });
+    return current;
+}
+function classifySteeringFollowUpEffect(text) {
+    const clauses = normalizeContinuityClauses(text);
+    let effect = "none";
+    if (clauses.some((clause) => CANCEL_SUPERSEDE_CLAUSES.has(clause))) {
+        effect = "clear_and_supersede";
+    }
+    else if (clauses.some((clause) => NO_HANDOFF_CLAUSES.has(clause))) {
+        effect = "set_no_handoff";
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.continuity_follow_up_classified",
+        message: "classified steering follow-up continuity effect",
+        meta: {
+            effect,
+            clauseCount: clauses.length,
+        },
+    });
+    return effect;
+}

package/dist/senses/debug-activity.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDebugActivityController = createDebugActivityController;
+const format_1 = require("../mind/format");
+const phrases_1 = require("../mind/phrases");
+const runtime_1 = require("../nerves/runtime");
+const progress_story_1 = require("../heart/progress-story");
+function createDebugActivityController(options) {
+    let queue = Promise.resolve();
+    let statusMessageGuid;
+    let typingActive = false;
+    let hadToolRun = false;
+    let followupShown = false;
+    let lastPhrase = "";
+    function reportTransportError(operation, error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.debug_activity_transport_error",
+            message: "debug activity transport failed",
+            meta: {
+                operation,
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+        options.onTransportError?.(operation, error);
+    }
+    function enqueue(operation, task) {
+        queue = queue
+            .then(task)
+            .catch((error) => {
+            reportTransportError(operation, error);
+        });
+    }
+    function nextPhrase(pool) {
+        const phrase = (0, phrases_1.pickPhrase)(pool, lastPhrase);
+        lastPhrase = phrase;
+        return phrase;
+    }
+    function startTypingNow() {
+        if (typingActive) {
+            return;
+        }
+        typingActive = true;
+        enqueue("typing_start", async () => {
+            await options.transport.setTyping(true);
+        });
+    }
+    function setStatus(text) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.debug_activity_update",
+            message: "debug activity status updated",
+            meta: {
+                hasStatusGuid: Boolean(statusMessageGuid),
+                textLength: text.length,
+            },
+        });
+        const shouldStartTyping = !typingActive;
+        if (shouldStartTyping) {
+            typingActive = true;
+        }
+        enqueue("status_update", async () => {
+            if (statusMessageGuid) {
+                await options.transport.editStatus(statusMessageGuid, text);
+            }
+            else {
+                statusMessageGuid = await options.transport.sendStatus(text);
+            }
+            if (shouldStartTyping) {
+                await options.transport.setTyping(true);
+            }
+        });
+    }
+    return {
+        onModelStart() {
+            const pool = hadToolRun ? options.followupPhrases : options.thinkingPhrases;
+            if (options.startTypingOnModelStart) {
+                startTypingNow();
+            }
+            if (options.suppressInitialModelStatus && !statusMessageGuid && !hadToolRun) {
+                nextPhrase(pool);
+                return;
+            }
+            setStatus((0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
+                scope: "shared-work",
+                phase: "processing",
+                objective: `${nextPhrase(pool)}...`,
+            })));
+        },
+        onToolStart(name, args) {
+            hadToolRun = true;
+            followupShown = false;
+            const argSummary = Object.values(args).join(", ");
+            const detail = argSummary ? ` (${argSummary})` : "";
+            setStatus((0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
+                scope: "shared-work",
+                phase: "processing",
+                objective: `running ${name}${detail}...`,
+            })));
+        },
+        onToolEnd(name, summary, success) {
+            hadToolRun = true;
+            followupShown = false;
+            setStatus((0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
+                scope: "shared-work",
+                phase: "processing",
+                objective: (0, format_1.formatToolResult)(name, summary, success),
+            })));
+        },
+        onTextChunk(text) {
+            if (!text) {
+                return;
+            }
+            if (!hadToolRun && options.startTypingOnFirstTextChunk) {
+                startTypingNow();
+            }
+            if (!hadToolRun || followupShown) {
+                return;
+            }
+            followupShown = true;
+            if (options.suppressFollowupPhraseStatus) {
+                return;
+            }
+            setStatus((0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
+                scope: "shared-work",
+                phase: "processing",
+                objective: `${nextPhrase(options.followupPhrases)}...`,
+            })));
+        },
+        onError(error) {
+            setStatus((0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
+                scope: "shared-work",
+                phase: "errored",
+                outcomeText: (0, format_1.formatError)(error),
+            })));
+            this.finish();
+        },
+        async drain() {
+            await queue;
+        },
+        async finish() {
+            if (!typingActive) {
+                await queue;
+                return;
+            }
+            typingActive = false;
+            enqueue("typing_stop", async () => {
+                await options.transport.setTyping(false);
+            });
+            await queue;
+        },
+    };
+}

package/dist/senses/inner-dialog-worker.js

@@ -4,26 +4,52 @@ exports.createInnerDialogWorker = createInnerDialogWorker;
 exports.startInnerDialogWorker = startInnerDialogWorker;
 const inner_dialog_1 = require("./inner-dialog");
 const runtime_1 = require("../nerves/runtime");
-function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runInnerDialogTurn)(options)) {
+const identity_1 = require("../heart/identity");
+const pending_1 = require("../mind/pending");
+function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runInnerDialogTurn)(options), hasPendingWork = () => (0, pending_1.hasPendingMessages)((0, pending_1.getInnerDialogPendingDir)((0, identity_1.getAgentName)()))) {
     let running = false;
-    async function run(reason) {
-        if (running)
+    let rerunRequested = false;
+    let rerunReason = "instinct";
+    let rerunTaskId;
+    async function run(reason, taskId) {
+        if (running) {
+            rerunRequested = true;
+            rerunReason = reason;
+            if (taskId !== undefined) {
+                rerunTaskId = taskId;
+            }
             return;
+        }
         running = true;
         try {
-            await runTurn({ reason });
-        }
-        catch (error) {
-            (0, runtime_1.emitNervesEvent)({
-                level: "error",
-                component: "senses",
-                event: "senses.inner_dialog_worker_error",
-                message: "inner dialog worker turn failed",
-                meta: {
-                    reason,
-                    error: error instanceof Error ? error.message : String(error),
-                },
-            });
+            let nextReason = reason;
+            let nextTaskId = taskId;
+            do {
+                rerunRequested = false;
+                try {
+                    await runTurn({ reason: nextReason, taskId: nextTaskId });
+                }
+                catch (error) {
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "error",
+                        component: "senses",
+                        event: "senses.inner_dialog_worker_error",
+                        message: "inner dialog worker turn failed",
+                        meta: {
+                            reason: nextReason,
+                            error: error instanceof Error ? error.message : String(error),
+                        },
+                    });
+                }
+                if (!rerunRequested && hasPendingWork()) {
+                    rerunRequested = true;
+                    rerunReason = "instinct";
+                }
+                nextReason = rerunReason;
+                nextTaskId = rerunTaskId;
+                rerunReason = "instinct";
+                rerunTaskId = undefined;
+            } while (rerunRequested);
         }
         finally {
             running = false;
@@ -37,8 +63,11 @@ function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runIn
             await run("heartbeat");
             return;
         }
-        if (maybeMessage.type === "poke" ||
-            maybeMessage.type === "chat" ||
+        if (maybeMessage.type === "poke") {
+            await run("instinct", maybeMessage.taskId);
+            return;
+        }
+        if (maybeMessage.type === "chat" ||
             maybeMessage.type === "message") {
             await run("instinct");
             return;