@ouro.bot/cli 0.1.0-alpha.1 → 0.1.0-alpha.100

package/dist/heart/bridges/state-machine.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBridgeState = createBridgeState;
+exports.bridgeStateLabel = bridgeStateLabel;
+exports.activateBridge = activateBridge;
+exports.beginBridgeProcessing = beginBridgeProcessing;
+exports.queueBridgeFollowUp = queueBridgeFollowUp;
+exports.advanceBridgeAfterTurn = advanceBridgeAfterTurn;
+exports.suspendBridge = suspendBridge;
+exports.completeBridge = completeBridge;
+exports.cancelBridge = cancelBridge;
+exports.reconcileBridgeState = reconcileBridgeState;
+const runtime_1 = require("../../nerves/runtime");
+function transition(state, next, action) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.bridge_state_transition",
+        message: "bridge state transitioned",
+        meta: {
+            action,
+            from: bridgeStateLabel(state),
+            to: bridgeStateLabel(next),
+        },
+    });
+    return next;
+}
+function assertNonTerminal(state, action) {
+    if (state.lifecycle === "completed" || state.lifecycle === "cancelled") {
+        throw new Error(`cannot ${action} a terminal bridge`);
+    }
+}
+function createBridgeState() {
+    return {
+        lifecycle: "forming",
+        runtime: "idle",
+    };
+}
+function bridgeStateLabel(state) {
+    switch (state.lifecycle) {
+        case "forming":
+            return "forming";
+        case "suspended":
+            return "suspended";
+        case "completed":
+            return "completed";
+        case "cancelled":
+            return "cancelled";
+        case "active":
+            if (state.runtime === "processing")
+                return "active-processing";
+            if (state.runtime === "awaiting-follow-up")
+                return "awaiting-follow-up";
+            return "active-idle";
+    }
+}
+function activateBridge(state) {
+    assertNonTerminal(state, "activate");
+    if (state.lifecycle !== "forming" && state.lifecycle !== "suspended") {
+        throw new Error("cannot activate bridge from current state");
+    }
+    return transition(state, { lifecycle: "active", runtime: "idle" }, "activate");
+}
+function beginBridgeProcessing(state) {
+    assertNonTerminal(state, "process");
+    if (state.lifecycle !== "active" || state.runtime !== "idle") {
+        throw new Error("cannot process bridge from current state");
+    }
+    return transition(state, { lifecycle: "active", runtime: "processing" }, "begin-processing");
+}
+function queueBridgeFollowUp(state) {
+    assertNonTerminal(state, "queue");
+    if (state.lifecycle !== "active") {
+        throw new Error("cannot queue follow-up for non-active bridge");
+    }
+    if (state.runtime === "processing") {
+        return transition(state, { lifecycle: "active", runtime: "awaiting-follow-up" }, "queue-follow-up");
+    }
+    if (state.runtime === "awaiting-follow-up") {
+        return state;
+    }
+    throw new Error("cannot queue follow-up when bridge is not processing");
+}
+function advanceBridgeAfterTurn(state) {
+    assertNonTerminal(state, "advance");
+    if (state.lifecycle !== "active") {
+        throw new Error("cannot advance non-active bridge");
+    }
+    if (state.runtime === "processing") {
+        return transition(state, { lifecycle: "active", runtime: "idle" }, "finish-processing");
+    }
+    if (state.runtime === "awaiting-follow-up") {
+        return transition(state, { lifecycle: "active", runtime: "processing" }, "resume-follow-up");
+    }
+    throw new Error("cannot advance an idle bridge");
+}
+function suspendBridge(state) {
+    assertNonTerminal(state, "suspend");
+    if ((state.lifecycle !== "forming" && state.lifecycle !== "active") || state.runtime !== "idle") {
+        throw new Error("cannot suspend bridge from current state");
+    }
+    return transition(state, { lifecycle: "suspended", runtime: "idle" }, "suspend");
+}
+function completeBridge(state) {
+    assertNonTerminal(state, "complete");
+    if (state.runtime !== "idle") {
+        throw new Error("cannot complete a bridge mid-turn");
+    }
+    return transition(state, { lifecycle: "completed", runtime: "idle" }, "complete");
+}
+function cancelBridge(state) {
+    assertNonTerminal(state, "cancel");
+    if (state.runtime !== "idle") {
+        throw new Error("cannot cancel a bridge mid-turn");
+    }
+    return transition(state, { lifecycle: "cancelled", runtime: "idle" }, "cancel");
+}
+function reconcileBridgeState(state, input) {
+    if (state.lifecycle === "completed" || state.lifecycle === "cancelled") {
+        return state;
+    }
+    if (state.runtime !== "idle") {
+        return state;
+    }
+    const hasLiveSignal = input.hasAttachedSessionActivity || input.hasLiveTask || input.currentSessionAttached;
+    if (state.lifecycle === "suspended") {
+        return hasLiveSignal ? activateBridge(state) : state;
+    }
+    if (state.lifecycle === "forming") {
+        return hasLiveSignal ? activateBridge(state) : suspendBridge(state);
+    }
+    if (state.lifecycle === "active") {
+        return hasLiveSignal ? state : suspendBridge(state);
+    }
+    return state;
+}

package/dist/heart/bridges/store.js

@@ -0,0 +1,123 @@
+"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.getBridgeStateRoot = getBridgeStateRoot;
+exports.createBridgeStore = createBridgeStore;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const identity_1 = require("../identity");
+const runtime_1 = require("../../nerves/runtime");
+function sessionIdentityMatches(session, candidate) {
+    return (session.friendId === candidate.friendId
+        && session.channel === candidate.channel
+        && session.key === candidate.key);
+}
+function bridgeFilePath(rootDir, id) {
+    return path.join(rootDir, `${id}.json`);
+}
+function getBridgeStateRoot() {
+    return path.join((0, identity_1.getAgentStateRoot)(), "bridges");
+}
+function createBridgeStore(options = {}) {
+    const rootDir = options.rootDir ?? getBridgeStateRoot();
+    function ensureRoot() {
+        fs.mkdirSync(rootDir, { recursive: true });
+    }
+    return {
+        save(bridge) {
+            ensureRoot();
+            fs.writeFileSync(bridgeFilePath(rootDir, bridge.id), JSON.stringify(bridge, null, 2), "utf-8");
+            (0, runtime_1.emitNervesEvent)({
+                component: "engine",
+                event: "engine.bridge_store_save",
+                message: "saved bridge record",
+                meta: {
+                    bridgeId: bridge.id,
+                    rootDir,
+                },
+            });
+            return bridge;
+        },
+        get(id) {
+            const filePath = bridgeFilePath(rootDir, id);
+            try {
+                const raw = fs.readFileSync(filePath, "utf-8");
+                return JSON.parse(raw);
+            }
+            catch {
+                return null;
+            }
+        },
+        list() {
+            ensureRoot();
+            const files = fs.readdirSync(rootDir).filter((entry) => entry.endsWith(".json")).sort();
+            const bridges = files
+                .map((fileName) => {
+                try {
+                    return JSON.parse(fs.readFileSync(path.join(rootDir, fileName), "utf-8"));
+                }
+                catch {
+                    return null;
+                }
+            })
+                .filter((bridge) => bridge !== null);
+            (0, runtime_1.emitNervesEvent)({
+                component: "engine",
+                event: "engine.bridge_store_list",
+                message: "listed bridge records",
+                meta: {
+                    rootDir,
+                    count: bridges.length,
+                },
+            });
+            return bridges;
+        },
+        findBySession(session) {
+            const matches = this.list().filter((bridge) => bridge.attachedSessions.some((candidate) => sessionIdentityMatches(session, candidate)));
+            (0, runtime_1.emitNervesEvent)({
+                component: "engine",
+                event: "engine.bridge_store_find_by_session",
+                message: "located bridges for canonical session",
+                meta: {
+                    friendId: session.friendId,
+                    channel: session.channel,
+                    key: session.key,
+                    count: matches.length,
+                },
+            });
+            return matches;
+        },
+    };
+}

package/dist/heart/commitments.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveCommitments = deriveCommitments;
+exports.formatCommitments = formatCommitments;
+const obligations_1 = require("./obligations");
+const runtime_1 = require("../nerves/runtime");
+function describeActiveObligation(obligation) {
+    if (obligation.status === "pending") {
+        return `i owe ${obligation.origin.friendId}: ${obligation.content}`;
+    }
+    const surface = obligation.currentSurface?.label;
+    const statusText = obligation.status.replaceAll("_", " ");
+    if (surface) {
+        return `i owe ${obligation.origin.friendId}: ${obligation.content} (${statusText} in ${surface})`;
+    }
+    return `i owe ${obligation.origin.friendId}: ${obligation.content} (${statusText})`;
+}
+function deriveCommitments(activeWorkFrame, innerJob, pendingObligations) {
+    const committedTo = [];
+    const completionCriteria = [];
+    const safeToIgnore = [];
+    // Persistent obligations from the obligation store
+    if (pendingObligations && pendingObligations.length > 0) {
+        let hasAdvancedObligation = false;
+        for (const ob of pendingObligations) {
+            if (!(0, obligations_1.isOpenObligationStatus)(ob.status))
+                continue;
+            committedTo.push(describeActiveObligation(ob));
+            if (ob.status !== "pending")
+                hasAdvancedObligation = true;
+        }
+        completionCriteria.push("fulfill my outstanding obligations");
+        if (hasAdvancedObligation) {
+            completionCriteria.push("close my active obligation loops");
+        }
+    }
+    // Obligation (from current turn -- kept for backward compat)
+    if (typeof activeWorkFrame.currentObligation === "string" && activeWorkFrame.currentObligation.trim().length > 0) {
+        committedTo.push(`i told them i'd ${activeWorkFrame.currentObligation.trim()}`);
+    }
+    // Inner job
+    if (innerJob.status === "queued" || innerJob.status === "running") {
+        const contentSuffix = innerJob.content ? ` -- ${innerJob.content.slice(0, 60)}` : "";
+        committedTo.push(`i'm thinking through something privately${contentSuffix}`);
+    }
+    else if (innerJob.status === "surfaced") {
+        committedTo.push("i finished thinking about something and need to bring it back");
+    }
+    // mustResolveBeforeHandoff
+    if (activeWorkFrame.mustResolveBeforeHandoff) {
+        committedTo.push("i need to finish what i started before moving on");
+        completionCriteria.push("resolve the current thread before moving on");
+    }
+    // Bridges
+    for (const bridge of activeWorkFrame.bridges) {
+        committedTo.push(`i have shared work: ${bridge.summary || bridge.objective}`);
+    }
+    if (activeWorkFrame.bridges.length > 0) {
+        completionCriteria.push("keep shared work aligned across sessions");
+    }
+    // Tasks
+    for (const taskName of activeWorkFrame.taskPressure?.liveTaskNames ?? []) {
+        committedTo.push(`i'm tracking: ${taskName}`);
+    }
+    // Obligation completion criteria
+    if (innerJob.obligationStatus === "pending") {
+        const name = innerJob.origin?.friendName ?? innerJob.origin?.friendId ?? "them";
+        completionCriteria.push(`bring my answer back to ${name}`);
+    }
+    // Default completion criteria
+    if (completionCriteria.length === 0) {
+        completionCriteria.push("just be present in this conversation");
+    }
+    // Safe to ignore
+    if (innerJob.status === "idle" && !(activeWorkFrame.inner?.hasPending)) {
+        safeToIgnore.push("no private thinking in progress");
+    }
+    if (activeWorkFrame.bridges.length === 0) {
+        safeToIgnore.push("no shared work to coordinate");
+    }
+    if ((activeWorkFrame.taskPressure?.liveTaskNames ?? []).length === 0) {
+        safeToIgnore.push("no active tasks to track");
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.commitments_derive",
+        message: "derived commitments frame",
+        meta: { committedCount: committedTo.length, criteriaCount: completionCriteria.length },
+    });
+    return { committedTo, completionCriteria, safeToIgnore };
+}
+function formatCommitments(commitments) {
+    const sections = [];
+    if (commitments.committedTo.length === 0) {
+        sections.push("i'm not holding anything specific right now. i'm free to be present.");
+    }
+    else {
+        sections.push("## what i'm holding right now");
+        sections.push("");
+        sections.push(commitments.committedTo.map((c) => `- ${c}`).join("\n"));
+    }
+    sections.push("");
+    sections.push("## what \"done\" looks like");
+    sections.push(commitments.completionCriteria.map((c) => `- ${c}`).join("\n"));
+    sections.push("");
+    sections.push("## what i can let go of");
+    sections.push(commitments.safeToIgnore.map((c) => `- ${c}`).join("\n"));
+    return sections.join("\n");
+}

package/dist/heart/config.js

@@ -35,23 +35,30 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadConfig = loadConfig;
 exports.resetConfigCache = resetConfigCache;
-exports.setTestConfig = setTestConfig;
+exports.patchRuntimeConfig = patchRuntimeConfig;
 exports.getAzureConfig = getAzureConfig;
 exports.getMinimaxConfig = getMinimaxConfig;
 exports.getAnthropicConfig = getAnthropicConfig;
 exports.getOpenAICodexConfig = getOpenAICodexConfig;
+exports.getGithubCopilotConfig = getGithubCopilotConfig;
 exports.getTeamsConfig = getTeamsConfig;
+exports.getTeamsSecondaryConfig = getTeamsSecondaryConfig;
 exports.getContextConfig = getContextConfig;
 exports.getOAuthConfig = getOAuthConfig;
+exports.resolveOAuthForTenant = resolveOAuthForTenant;
 exports.getTeamsChannelConfig = getTeamsChannelConfig;
+exports.getBlueBubblesConfig = getBlueBubblesConfig;
+exports.getBlueBubblesChannelConfig = getBlueBubblesChannelConfig;
 exports.getIntegrationsConfig = getIntegrationsConfig;
 exports.getOpenAIEmbeddingsApiKey = getOpenAIEmbeddingsApiKey;
 exports.getLogsDir = getLogsDir;
+exports.sanitizeKey = sanitizeKey;
+exports.slugify = slugify;
+exports.resolveSessionPath = resolveSessionPath;
 exports.sessionPath = sessionPath;
 exports.logPath = logPath;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const os = __importStar(require("os"));
 const identity_1 = require("./identity");
 const runtime_1 = require("../nerves/runtime");
 const DEFAULT_SECRETS_TEMPLATE = {
@@ -64,6 +71,7 @@ const DEFAULT_SECRETS_TEMPLATE = {
             endpoint: "",
             deployment: "",
             apiVersion: "2025-04-01-preview",
+            managedIdentityClientId: "",
         },
         minimax: {
             model: "",
@@ -74,24 +82,46 @@ const DEFAULT_SECRETS_TEMPLATE = {
             setupToken: "",
         },
         "openai-codex": {
-            model: "gpt-5.2",
+            model: "gpt-5.4",
             oauthAccessToken: "",
         },
+        "github-copilot": {
+            model: "claude-sonnet-4.6",
+            githubToken: "",
+            baseUrl: "",
+        },
     },
     teams: {
         clientId: "",
         clientSecret: "",
         tenantId: "",
+        managedIdentityClientId: "",
     },
     oauth: {
         graphConnectionName: "graph",
         adoConnectionName: "ado",
         githubConnectionName: "",
     },
+    teamsSecondary: {
+        clientId: "",
+        clientSecret: "",
+        tenantId: "",
+        managedIdentityClientId: "",
+    },
     teamsChannel: {
         skipConfirmation: true,
         port: 3978,
     },
+    bluebubbles: {
+        serverUrl: "",
+        password: "",
+        accountId: "default",
+    },
+    bluebubblesChannel: {
+        port: 18790,
+        webhookPath: "/bluebubbles-webhook",
+        requestTimeoutMs: 30000,
+    },
     integrations: {
         perplexityApiKey: "",
         openaiEmbeddingsApiKey: "",
@@ -104,15 +134,19 @@ function defaultRuntimeConfig() {
             minimax: { ...DEFAULT_SECRETS_TEMPLATE.providers.minimax },
             anthropic: { ...DEFAULT_SECRETS_TEMPLATE.providers.anthropic },
             "openai-codex": { ...DEFAULT_SECRETS_TEMPLATE.providers["openai-codex"] },
+            "github-copilot": { ...DEFAULT_SECRETS_TEMPLATE.providers["github-copilot"] },
         },
         teams: { ...DEFAULT_SECRETS_TEMPLATE.teams },
+        teamsSecondary: { ...DEFAULT_SECRETS_TEMPLATE.teamsSecondary },
         oauth: { ...DEFAULT_SECRETS_TEMPLATE.oauth },
         context: { ...identity_1.DEFAULT_AGENT_CONTEXT },
         teamsChannel: { ...DEFAULT_SECRETS_TEMPLATE.teamsChannel },
+        bluebubbles: { ...DEFAULT_SECRETS_TEMPLATE.bluebubbles },
+        bluebubblesChannel: { ...DEFAULT_SECRETS_TEMPLATE.bluebubblesChannel },
         integrations: { ...DEFAULT_SECRETS_TEMPLATE.integrations },
     };
 }
-let _cachedConfig = null;
+let _runtimeConfigOverride = null;
 let _testContextOverride = null;
 function resolveConfigPath() {
     return (0, identity_1.getAgentSecretsPath)();
@@ -134,15 +168,6 @@ function deepMerge(defaults, partial) {
     return result;
 }
 function loadConfig() {
-    if (_cachedConfig) {
-        (0, runtime_1.emitNervesEvent)({
-            event: "config.load",
-            component: "config/identity",
-            message: "config loaded from cache",
-            meta: { source: "cache" },
-        });
-        return _cachedConfig;
-    }
     const configPath = resolveConfigPath();
     // Auto-create config directory if it doesn't exist
     const configDir = path.dirname(configPath);
@@ -203,7 +228,10 @@ function loadConfig() {
             },
         });
     }
-    _cachedConfig = deepMerge(defaultRuntimeConfig(), sanitizedFileData);
+    const mergedConfig = deepMerge(defaultRuntimeConfig(), sanitizedFileData);
+    const config = _runtimeConfigOverride
+        ? deepMerge(mergedConfig, _runtimeConfigOverride)
+        : mergedConfig;
     (0, runtime_1.emitNervesEvent)({
         event: "config.load",
         component: "config/identity",
@@ -211,22 +239,22 @@ function loadConfig() {
         meta: {
             source: "disk",
             used_defaults_only: Object.keys(fileData).length === 0,
+            override_applied: _runtimeConfigOverride !== null,
         },
     });
-    return _cachedConfig;
+    return config;
 }
 function resetConfigCache() {
-    _cachedConfig = null;
+    _runtimeConfigOverride = null;
     _testContextOverride = null;
 }
-function setTestConfig(partial) {
-    loadConfig(); // ensure _cachedConfig exists
+function patchRuntimeConfig(partial) {
     const contextPatch = partial.context;
     if (contextPatch) {
         const base = _testContextOverride ?? identity_1.DEFAULT_AGENT_CONTEXT;
         _testContextOverride = deepMerge(base, contextPatch);
     }
-    _cachedConfig = deepMerge(_cachedConfig, partial);
+    _runtimeConfigOverride = deepMerge((_runtimeConfigOverride ?? {}), partial);
 }
 function getAzureConfig() {
     const config = loadConfig();
@@ -244,10 +272,18 @@ function getOpenAICodexConfig() {
     const config = loadConfig();
     return { ...config.providers["openai-codex"] };
 }
+function getGithubCopilotConfig() {
+    const config = loadConfig();
+    return { ...config.providers["github-copilot"] };
+}
 function getTeamsConfig() {
     const config = loadConfig();
     return { ...config.teams };
 }
+function getTeamsSecondaryConfig() {
+    const config = loadConfig();
+    return { ...config.teamsSecondary };
+}
 function getContextConfig() {
     if (_testContextOverride) {
         return { ..._testContextOverride };
@@ -268,11 +304,41 @@ function getOAuthConfig() {
     const config = loadConfig();
     return { ...config.oauth };
 }
+/** Resolve OAuth connection names for a specific tenant, falling back to defaults. */
+function resolveOAuthForTenant(tenantId) {
+    const base = getOAuthConfig();
+    const overrides = tenantId ? base.tenantOverrides?.[tenantId] : undefined;
+    return {
+        graphConnectionName: overrides?.graphConnectionName ?? base.graphConnectionName,
+        adoConnectionName: overrides?.adoConnectionName ?? base.adoConnectionName,
+        githubConnectionName: overrides?.githubConnectionName ?? base.githubConnectionName,
+    };
+}
 function getTeamsChannelConfig() {
     const config = loadConfig();
     const { skipConfirmation, flushIntervalMs, port } = config.teamsChannel;
     return { skipConfirmation, flushIntervalMs, port };
 }
+function getBlueBubblesConfig() {
+    const config = loadConfig();
+    const { serverUrl, password, accountId } = config.bluebubbles;
+    if (!serverUrl.trim()) {
+        throw new Error("bluebubbles.serverUrl is required in secrets.json to run the BlueBubbles sense.");
+    }
+    if (!password.trim()) {
+        throw new Error("bluebubbles.password is required in secrets.json to run the BlueBubbles sense.");
+    }
+    return {
+        serverUrl: serverUrl.trim(),
+        password: password.trim(),
+        accountId: accountId.trim() || "default",
+    };
+}
+function getBlueBubblesChannelConfig() {
+    const config = loadConfig();
+    const { port, webhookPath, requestTimeoutMs } = config.bluebubblesChannel;
+    return { port, webhookPath, requestTimeoutMs };
+}
 function getIntegrationsConfig() {
     const config = loadConfig();
     return { ...config.integrations };
@@ -281,16 +347,29 @@ function getOpenAIEmbeddingsApiKey() {
     return getIntegrationsConfig().openaiEmbeddingsApiKey;
 }
 function getLogsDir() {
-    return path.join(os.homedir(), ".agentstate", (0, identity_1.getAgentName)(), "logs");
+    return path.join((0, identity_1.getAgentRoot)(), "state", "logs");
 }
 function sanitizeKey(key) {
     return key.replace(/[/:]/g, "_");
 }
-function sessionPath(friendId, channel, key) {
-    const dir = path.join(os.homedir(), ".agentstate", (0, identity_1.getAgentName)(), "sessions", friendId, channel);
-    fs.mkdirSync(dir, { recursive: true });
+function slugify(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+/, "")
+        .replace(/-+$/, "");
+}
+function resolveSessionPath(friendId, channel, key, options) {
+    const dir = path.join((0, identity_1.getAgentRoot)(), "state", "sessions", friendId, channel);
+    if (options?.ensureDir) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
     return path.join(dir, sanitizeKey(key) + ".json");
 }
+function sessionPath(friendId, channel, key) {
+    return resolveSessionPath(friendId, channel, key, { ensureDir: true });
+}
 function logPath(channel, key) {
     return path.join(getLogsDir(), channel, sanitizeKey(key) + ".ndjson");
 }