@ouro.bot/cli 0.1.0-alpha.45 → 0.1.0-alpha.451

package/dist/mailroom/smtp-ingress.js

@@ -0,0 +1,176 @@
+"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.createMailroomSmtpServer = createMailroomSmtpServer;
+exports.createMailroomHealthServer = createMailroomHealthServer;
+exports.startMailroomIngress = startMailroomIngress;
+const http = __importStar(require("node:http"));
+const smtp_server_1 = require("smtp-server");
+const runtime_1 = require("../nerves/runtime");
+const core_1 = require("./core");
+const file_store_1 = require("./file-store");
+function collectStream(stream, maxBytes) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let total = 0;
+        stream.on("data", (chunk) => {
+            total += chunk.byteLength;
+            if (total > maxBytes) {
+                reject(new Error(`message exceeds max size ${maxBytes}`));
+                stream.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        stream.on("error", reject);
+        stream.on("end", () => resolve(Buffer.concat(chunks)));
+    });
+}
+function sessionRecipients(session) {
+    /* v8 ignore next -- smtp-server supplies rcptTo during DATA; fallback is a defensive harness edge. @preserve */
+    return (session.envelope.rcptTo ?? []).map((address) => (0, core_1.normalizeMailAddress)(address.address));
+}
+function createMailroomSmtpServer(options) {
+    const maxMessageBytes = options.maxMessageBytes ?? 25 * 1024 * 1024;
+    const server = new smtp_server_1.SMTPServer({
+        disabledCommands: ["AUTH", "STARTTLS"],
+        logger: false,
+        onRcptTo(address, _session, callback) {
+            const normalized = (0, core_1.normalizeMailAddress)(address.address);
+            const resolved = (0, core_1.resolveMailAddress)(options.registry, normalized);
+            if (!resolved) {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "senses",
+                    event: "senses.mail_smtp_recipient_rejected",
+                    message: "smtp recipient rejected",
+                    meta: { address: normalized },
+                });
+                const error = new Error(`unknown recipient ${normalized}`);
+                error.responseCode = 550;
+                callback(error);
+                return;
+            }
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.mail_smtp_recipient_accepted",
+                message: "smtp recipient accepted",
+                meta: { address: normalized, agentId: resolved.agentId },
+            });
+            callback();
+        },
+        async onData(stream, session, callback) {
+            try {
+                const raw = await collectStream(stream, maxMessageBytes);
+                const mailFrom = session.envelope.mailFrom;
+                /* v8 ignore next -- smtp-server exposes normal and null senders as address objects; false/undefined are defensive direct-call states. @preserve */
+                const rawMailFrom = mailFrom === false ? "" : mailFrom?.address ?? "";
+                const envelope = {
+                    mailFrom: rawMailFrom ? (0, core_1.normalizeMailAddress)(rawMailFrom) : "",
+                    rcptTo: sessionRecipients(session),
+                    /* v8 ignore next -- smtp-server network sessions carry remoteAddress; fallback is a defensive direct-call edge. @preserve */
+                    ...(session.remoteAddress ? { remoteAddress: session.remoteAddress } : {}),
+                };
+                const result = await (0, file_store_1.ingestRawMailToStore)({
+                    registry: options.registry,
+                    store: options.store,
+                    envelope,
+                    rawMime: raw,
+                });
+                (0, runtime_1.emitNervesEvent)({
+                    component: "senses",
+                    event: "senses.mail_smtp_data_stored",
+                    message: "smtp data stored",
+                    meta: { accepted: result.accepted.length, rejected: result.rejectedRecipients.length },
+                });
+                callback();
+            }
+            catch (error) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "senses",
+                    event: "senses.mail_smtp_data_error",
+                    message: "smtp data handling failed",
+                    meta: { error: error instanceof Error ? error.message : String(error) },
+                });
+                callback(error instanceof Error ? error : new Error(String(error)));
+            }
+        },
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.mail_smtp_server_created",
+        message: "mailroom smtp server created",
+        meta: { maxMessageBytes },
+    });
+    return server;
+}
+function createMailroomHealthServer(registry) {
+    const server = http.createServer((_request, response) => {
+        const body = JSON.stringify({
+            ok: true,
+            service: "ouro-mailroom",
+            domain: registry.domain,
+            mailboxes: registry.mailboxes.length,
+            sourceGrants: registry.sourceGrants.length,
+        });
+        response.writeHead(200, {
+            "content-type": "application/json",
+            "content-length": Buffer.byteLength(body),
+        });
+        response.end(body);
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.mail_health_server_created",
+        message: "mailroom health server created",
+        meta: { domain: registry.domain },
+    });
+    return server;
+}
+function startMailroomIngress(options) {
+    const smtp = createMailroomSmtpServer(options);
+    const health = createMailroomHealthServer(options.registry);
+    /* v8 ignore next -- production/container entrypoints may omit host; unit tests bind loopback explicitly. @preserve */
+    const host = options.host ?? "0.0.0.0";
+    smtp.listen(options.smtpPort, host);
+    health.listen(options.httpPort, host);
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.mail_ingress_started",
+        message: "mailroom ingress started",
+        meta: { smtpPort: options.smtpPort, httpPort: options.httpPort, host },
+    });
+    return { smtp, health };
+}

package/dist/mind/bundle-manifest.js

@@ -52,7 +52,13 @@ exports.CANONICAL_BUNDLE_MANIFEST = [
     { path: "psyche/LORE.md", kind: "file" },
     { path: "psyche/TACIT.md", kind: "file" },
     { path: "psyche/ASPIRATIONS.md", kind: "file" },
-    { path: "psyche/memory", kind: "dir" },
+    { path: "arc", kind: "dir" },
+    { path: "arc/episodes", kind: "dir" },
+    { path: "arc/obligations", kind: "dir" },
+    { path: "arc/cares", kind: "dir" },
+    { path: "arc/intentions", kind: "dir" },
+    { path: "diary", kind: "dir" },
+    { path: "journal", kind: "dir" },
     { path: "friends", kind: "dir" },
     { path: "state", kind: "dir" },
     { path: "tasks", kind: "dir" },

package/dist/mind/context.js

@@ -33,18 +33,26 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSessionMessages = exports.repairSessionMessages = exports.migrateToolNames = void 0;
 exports.trimMessages = trimMessages;
-exports.validateSessionMessages = validateSessionMessages;
-exports.repairSessionMessages = repairSessionMessages;
 exports.saveSession = saveSession;
+exports.appendSyntheticAssistantMessage = appendSyntheticAssistantMessage;
 exports.loadSession = loadSession;
 exports.postTurn = postTurn;
+exports.postTurnTrim = postTurnTrim;
+exports.postTurnPersist = postTurnPersist;
+exports.deferPostTurnPersist = deferPostTurnPersist;
 exports.deleteSession = deleteSession;
 const config_1 = require("../heart/config");
+const session_events_1 = require("../heart/session-events");
 const runtime_1 = require("../nerves/runtime");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const token_estimate_1 = require("./token-estimate");
+var session_events_2 = require("../heart/session-events");
+Object.defineProperty(exports, "migrateToolNames", { enumerable: true, get: function () { return session_events_2.migrateToolNames; } });
+Object.defineProperty(exports, "repairSessionMessages", { enumerable: true, get: function () { return session_events_2.repairSessionMessages; } });
+Object.defineProperty(exports, "validateSessionMessages", { enumerable: true, get: function () { return session_events_2.validateSessionMessages; } });
 function buildTrimmableBlocks(messages) {
     const blocks = [];
     let i = 0;
@@ -173,114 +181,94 @@ function trimMessages(messages, maxTokens, contextMargin, actualTokenCount) {
  * user → assistant (with optional tool calls/results) → user → assistant...
  * Never assistant → assistant without a user in between.
  */
-function validateSessionMessages(messages) {
-    const violations = [];
-    let prevNonToolRole = null;
-    let prevAssistantHadToolCalls = false;
-    let sawToolResultSincePrevAssistant = false;
-    for (let i = 0; i < messages.length; i++) {
-        const msg = messages[i];
-        if (msg.role === "system")
-            continue;
-        if (msg.role === "tool") {
-            sawToolResultSincePrevAssistant = true;
-            continue;
-        }
-        if (msg.role === "assistant" && prevNonToolRole === "assistant") {
-            // assistant → tool(s) → assistant is valid (tool call flow)
-            if (!(prevAssistantHadToolCalls && sawToolResultSincePrevAssistant)) {
-                violations.push(`back-to-back assistant at index ${i}`);
-            }
-        }
-        prevAssistantHadToolCalls = msg.role === "assistant" && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0;
-        sawToolResultSincePrevAssistant = false;
-        prevNonToolRole = msg.role;
-    }
-    return violations;
+function denormalizeContinuityState(state) {
+    if (!state.mustResolveBeforeHandoff && typeof state.lastFriendActivityAt !== "string")
+        return undefined;
+    return {
+        ...(state.mustResolveBeforeHandoff ? { mustResolveBeforeHandoff: true } : {}),
+        ...(typeof state.lastFriendActivityAt === "string" ? { lastFriendActivityAt: state.lastFriendActivityAt } : {}),
+    };
 }
-/**
- * Repairs session invariant violations by merging consecutive assistant messages.
- */
-function repairSessionMessages(messages) {
-    const violations = validateSessionMessages(messages);
-    if (violations.length === 0)
-        return messages;
-    const result = [];
-    for (const msg of messages) {
-        if (msg.role === "assistant" && result.length > 0) {
-            const prev = result[result.length - 1];
-            if (prev.role === "assistant" && !("tool_calls" in prev)) {
-                const prevContent = typeof prev.content === "string" ? prev.content : "";
-                const curContent = typeof msg.content === "string" ? msg.content : "";
-                prev.content = `${prevContent}\n\n${curContent}`;
-                continue;
-            }
-        }
-        result.push(msg);
-    }
-    (0, runtime_1.emitNervesEvent)({
-        level: "warn",
-        event: "mind.session_invariant_repair",
-        component: "mind",
-        message: "repaired session invariant violations",
-        meta: { violations },
-    });
-    return result;
+function writeSessionEnvelope(filePath, envelope) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(envelope, null, 2));
 }
 function saveSession(filePath, messages, lastUsage, state) {
-    const violations = validateSessionMessages(messages);
-    if (violations.length > 0) {
+    const existing = (0, session_events_1.loadSessionEnvelopeFile)(filePath);
+    const previousMessages = existing ? (0, session_events_1.projectProviderMessages)(existing) : [];
+    const currentIngressTimes = messages.map(session_events_1.getIngressTime);
+    const sanitized = (0, session_events_1.sanitizeProviderMessages)(messages);
+    const { envelope } = (0, session_events_1.buildCanonicalSessionEnvelope)({
+        existing,
+        previousMessages,
+        currentMessages: sanitized,
+        trimmedMessages: sanitized,
+        currentIngressTimes,
+        recordedAt: new Date().toISOString(),
+        lastUsage: lastUsage ?? null,
+        state,
+        projectionBasis: {
+            maxTokens: null,
+            contextMargin: null,
+            inputTokens: lastUsage?.input_tokens ?? null,
+        },
+    });
+    writeSessionEnvelope(filePath, envelope);
+}
+function appendSyntheticAssistantMessage(filePath, content) {
+    try {
+        if (!fs.existsSync(filePath))
+            return false;
+        const envelope = (0, session_events_1.loadSessionEnvelopeFile)(filePath);
+        if (!envelope)
+            return false;
+        const updated = (0, session_events_1.appendSyntheticAssistantEvent)(envelope, content, new Date().toISOString());
+        writeSessionEnvelope(filePath, updated);
         (0, runtime_1.emitNervesEvent)({
-            level: "warn",
-            event: "mind.session_invariant_violation",
             component: "mind",
-            message: "session invariant violated on save",
-            meta: { path: filePath, violations },
+            event: "mind.session_synthetic_message_appended",
+            message: "appended synthetic assistant message to session",
+            meta: { path: filePath, contentLength: content.length },
         });
-        messages = repairSessionMessages(messages);
+        return true;
     }
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    const envelope = { version: 1, messages };
-    if (lastUsage)
-        envelope.lastUsage = lastUsage;
-    if (state?.mustResolveBeforeHandoff === true) {
-        envelope.state = { mustResolveBeforeHandoff: true };
+    catch {
+        return false;
     }
-    fs.writeFileSync(filePath, JSON.stringify(envelope, null, 2));
 }
 function loadSession(filePath) {
     try {
-        const raw = fs.readFileSync(filePath, "utf-8");
-        const data = JSON.parse(raw);
-        if (data.version !== 1)
+        const envelope = (0, session_events_1.loadSessionEnvelopeFile)(filePath);
+        if (!envelope)
             return null;
-        let messages = data.messages;
-        const violations = validateSessionMessages(messages);
-        if (violations.length > 0) {
-            (0, runtime_1.emitNervesEvent)({
-                level: "warn",
-                event: "mind.session_invariant_violation",
-                component: "mind",
-                message: "session invariant violated on load",
-                meta: { path: filePath, violations },
-            });
-            messages = repairSessionMessages(messages);
-        }
-        const state = data?.state && typeof data.state === "object" && data.state !== null
-            && typeof data.state.mustResolveBeforeHandoff === "boolean"
-            && data.state.mustResolveBeforeHandoff === true
-            ? { mustResolveBeforeHandoff: true }
-            : undefined;
-        return { messages, lastUsage: data.lastUsage, state };
+        return {
+            messages: (0, session_events_1.annotateMessageTimestamps)(envelope, (0, session_events_1.projectProviderMessages)(envelope)),
+            events: envelope.events,
+            lastUsage: envelope.lastUsage ?? undefined,
+            state: denormalizeContinuityState(envelope.state),
+        };
     }
     catch {
         return null;
     }
 }
+/**
+ * Synchronous post-turn: sanitize, trim (mutates messages in place), and persist to disk.
+ * For non-blocking persist, use postTurnTrim() + deferPostTurnPersist() instead.
+ */
 function postTurn(messages, sessPath, usage, hooks, state) {
+    const prepared = postTurnTrim(messages, usage, hooks);
+    postTurnPersist(sessPath, prepared, usage, state);
+}
+/**
+ * Synchronous phase: run hooks, sanitize, trim, and mutate the messages array in place.
+ * Returns the data needed by postTurnPersist / deferPostTurnPersist.
+ */
+function postTurnTrim(messages, usage, hooks) {
+    const preTrimMessages = [...messages];
     if (hooks?.beforeTrim) {
         try {
-            hooks.beforeTrim([...messages]);
+            hooks.beforeTrim(preTrimMessages);
         }
         catch (error) {
             (0, runtime_1.emitNervesEvent)({
@@ -295,9 +283,60 @@ function postTurn(messages, sessPath, usage, hooks, state) {
         }
     }
     const { maxTokens, contextMargin } = (0, config_1.getContextConfig)();
-    const trimmed = trimMessages(messages, maxTokens, contextMargin, usage?.input_tokens);
-    messages.splice(0, messages.length, ...trimmed);
-    saveSession(sessPath, messages, usage, state);
+    const currentIngressTimes = messages.map(session_events_1.getIngressTime);
+    const currentMessages = (0, session_events_1.sanitizeProviderMessages)(messages);
+    const trimmedMessages = trimMessages(currentMessages, maxTokens, contextMargin, usage?.input_tokens);
+    messages.splice(0, messages.length, ...trimmedMessages);
+    return { currentMessages, trimmedMessages, currentIngressTimes, maxTokens, contextMargin };
+}
+/**
+ * Synchronous persist: load existing envelope, build canonical envelope, write to disk.
+ */
+function postTurnPersist(sessPath, prepared, usage, state) {
+    const existing = (0, session_events_1.loadSessionEnvelopeFile)(sessPath);
+    const previousMessages = existing ? (0, session_events_1.projectProviderMessages)(existing) : [];
+    const { envelope, evictedEvents } = (0, session_events_1.buildCanonicalSessionEnvelope)({
+        existing,
+        previousMessages,
+        currentMessages: prepared.currentMessages,
+        trimmedMessages: prepared.trimmedMessages,
+        currentIngressTimes: prepared.currentIngressTimes,
+        recordedAt: new Date().toISOString(),
+        lastUsage: usage ?? null,
+        state,
+        projectionBasis: {
+            maxTokens: prepared.maxTokens,
+            contextMargin: prepared.contextMargin,
+            inputTokens: usage?.input_tokens ?? null,
+        },
+    });
+    (0, session_events_1.appendEvictedToArchive)(sessPath, evictedEvents);
+    writeSessionEnvelope(sessPath, envelope);
+    return envelope.events;
+}
+/**
+ * Deferred persist: same as postTurnPersist but runs on the next event loop tick.
+ * Returns a promise that resolves when the persist completes.
+ */
+function deferPostTurnPersist(sessPath, prepared, usage, state) {
+    return new Promise((resolve) => {
+        setImmediate(() => {
+            try {
+                const events = postTurnPersist(sessPath, prepared, usage, state);
+                resolve(events);
+            }
+            catch (err) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "mind",
+                    event: "mind.deferred_persist_error",
+                    message: "deferred session persist failed",
+                    meta: { error: err instanceof Error ? err.message : String(err) },
+                });
+                resolve([]);
+            }
+        });
+    });
 }
 function deleteSession(filePath) {
     try {

package/dist/mind/diary-integrity.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectSuspiciousContent = detectSuspiciousContent;
+const PATTERN_CATEGORIES = [
+    {
+        name: "instruction_framing",
+        patterns: [
+            /\byou are (?:a|an) (?:ai|assistant|language model|helpful assistant)\b/i,
+            /\byour (?:new )?instructions are\b/i,
+            /\bsystem\s*:/i,
+            /\bignore (?:all |my )?previous instructions\b/i,
+            /\bdo not reveal\b/i,
+        ],
+    },
+    {
+        name: "override_language",
+        patterns: [
+            /\bdisregard\b/i,
+            /\bforget everything\b/i,
+            /\bnew instructions:/i,
+            /\boverride (?:all |any |previous )?instructions\b/i,
+        ],
+    },
+    {
+        name: "role_injection",
+        patterns: [
+            /\bas (?:a|an) (?:ai|language model)\b/i,
+            /\byou must always\b/i,
+            /\byou are now\b/i,
+        ],
+    },
+    {
+        name: "boundary_markers",
+        patterns: [
+            /```system/i,
+            /<<SYS>>/i,
+            /\[INST\]/i,
+            /<\/?system>/i,
+            /\[system\]/i,
+        ],
+    },
+];
+function detectSuspiciousContent(text) {
+    if (!text) {
+        return { suspicious: false, patterns: [] };
+    }
+    const matched = new Set();
+    for (const category of PATTERN_CATEGORIES) {
+        for (const pattern of category.patterns) {
+            if (pattern.test(text)) {
+                matched.add(category.name);
+                break;
+            }
+        }
+    }
+    return {
+        suspicious: matched.size > 0,
+        patterns: [...matched],
+    };
+}