@ouro.bot/cli 0.1.0-alpha.51 → 0.1.0-alpha.53

package/changelog.json

@@ -1,6 +1,23 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.53",
+      "changes": [
+        "Daemon plist now inherits PATH from the installing process, so child agent spawns can find node regardless of launchd's minimal default environment.",
+        "Daemon startup and status output now show the entry path and runtime mode (dev vs production) so it's immediately obvious where the daemon is running from and whether it's a dev repo, worktree, or npm install.",
+        "Agent spawn in the process manager now validates the entry script exists before calling spawn, setting the agent to crashed with a clear error instead of an opaque ENOENT.",
+        "Plist write warns when the entry path doesn't exist on disk, catching stale worktree paths before they cause daemon crashes."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.52",
+      "changes": [
+        "Trusted 1:1 chats can now act live across active group threads: the harness resolves candidate target chats, carries explicit trust context into the model, and delivers messages into the right live BlueBubbles or Teams session instead of only queueing for later.",
+        "People discovered through a relevant live group are now bootstrapped as acquaintances with shared-group context, so the agent gets a socially truthful model of who is merely unknown versus who is known through the current group.",
+        "Cross-chat work now returns a truthful outcome back to the asking chat, and bridge suggestions can span different outward relationships when one live piece of work is clearly happening across them."
+      ]
+    },
     {
       "version": "0.1.0-alpha.51",
       "changes": [

package/dist/heart/active-work.js

@@ -5,6 +5,7 @@ exports.buildActiveWorkFrame = buildActiveWorkFrame;
 exports.formatActiveWorkFrame = formatActiveWorkFrame;
 const runtime_1 = require("../nerves/runtime");
 const state_machine_1 = require("./bridges/state-machine");
+const target_resolution_1 = require("./target-resolution");
 function activityPriority(source) {
     return source === "friend-facing" ? 0 : 1;
 }
@@ -31,16 +32,28 @@ function hasSharedObligationPressure(input) {
         || summarizeLiveTasks(input.taskBoard).length > 0;
 }
 function suggestBridgeForActiveWork(input) {
-    const candidateSessions = input.friendSessions
-        .filter((session) => !input.currentSession
-        || session.friendId !== input.currentSession.friendId
-        || session.channel !== input.currentSession.channel
-        || session.key !== input.currentSession.key)
-        .sort(compareActivity);
-    const targetSession = candidateSessions[0] ?? null;
-    if (!targetSession || !hasSharedObligationPressure(input)) {
+    const targetCandidates = (input.targetCandidates ?? [])
+        .filter((candidate) => {
+        if (candidate.delivery.mode === "blocked") {
+            return false;
+        }
+        if (candidate.activitySource !== "friend-facing" || candidate.channel === "inner") {
+            return false;
+        }
+        if (!input.currentSession) {
+            return true;
+        }
+        return !(candidate.friendId === input.currentSession.friendId
+            && candidate.channel === input.currentSession.channel
+            && candidate.key === input.currentSession.key);
+    })
+        .sort((a, b) => {
+        return b.lastActivityMs - a.lastActivityMs;
+    });
+    if (!hasSharedObligationPressure(input) || targetCandidates.length !== 1) {
         return null;
     }
+    const targetSession = targetCandidates[0];
     const activeBridge = input.bridges.find(isActiveBridge) ?? null;
     if (activeBridge) {
         const alreadyAttached = activeBridge.attachedSessions.some((session) => session.friendId === targetSession.friendId
@@ -53,14 +66,14 @@ function suggestBridgeForActiveWork(input) {
             kind: "attach-existing",
             bridgeId: activeBridge.id,
             targetSession,
-            reason: "same-friend-shared-work",
+            reason: "shared-work-candidate",
         };
     }
     return {
         kind: "begin-new",
         targetSession,
         objectiveHint: input.currentObligation?.trim() || "keep this shared work aligned",
-        reason: "same-friend-shared-work",
+        reason: "shared-work-candidate",
     };
 }
 function formatSessionLabel(session) {
@@ -95,13 +108,14 @@ function buildActiveWorkFrame(input) {
             freshestForCurrentFriend: friendSessions[0] ?? null,
             otherLiveSessionsForCurrentFriend: friendSessions,
         },
+        targetCandidates: input.targetCandidates ?? [],
         bridgeSuggestion: suggestBridgeForActiveWork({
             currentSession: input.currentSession,
             currentObligation: input.currentObligation,
             mustResolveBeforeHandoff: input.mustResolveBeforeHandoff,
             bridges: input.bridges,
             taskBoard: input.taskBoard,
-            friendSessions,
+            targetCandidates: input.targetCandidates,
         }),
     };
     (0, runtime_1.emitNervesEvent)({
@@ -144,6 +158,13 @@ function formatActiveWorkFrame(frame) {
     if (frame.friendActivity?.freshestForCurrentFriend) {
         lines.push(`freshest friend-facing session: ${formatSessionLabel(frame.friendActivity.freshestForCurrentFriend)}`);
     }
+    const targetCandidatesBlock = frame.targetCandidates && frame.targetCandidates.length > 0
+        ? (0, target_resolution_1.formatTargetSessionCandidates)(frame.targetCandidates)
+        : "";
+    if (targetCandidatesBlock) {
+        lines.push("");
+        lines.push(targetCandidatesBlock);
+    }
     if (frame.bridgeSuggestion) {
         if (frame.bridgeSuggestion.kind === "attach-existing") {
             lines.push(`suggested bridge: attach ${frame.bridgeSuggestion.bridgeId} -> ${formatSessionLabel(frame.bridgeSuggestion.targetSession)}`);

package/dist/heart/cross-chat-delivery.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deliverCrossChatMessage = deliverCrossChatMessage;
+const types_1 = require("../mind/friends/types");
+const runtime_1 = require("../nerves/runtime");
+function buildPendingEnvelope(request, agentName, now) {
+    return {
+        from: agentName,
+        friendId: request.friendId,
+        channel: request.channel,
+        key: request.key,
+        content: request.content,
+        timestamp: now,
+    };
+}
+function queueForLater(request, deps, detail) {
+    deps.queuePending(buildPendingEnvelope(request, deps.agentName, (deps.now ?? Date.now)()));
+    return {
+        status: "queued_for_later",
+        detail,
+    };
+}
+function isExplicitlyAuthorized(request) {
+    return request.intent === "explicit_cross_chat"
+        && Boolean(request.authorizingSession)
+        && (0, types_1.isTrustedLevel)(request.authorizingSession?.trustLevel);
+}
+async function deliverCrossChatMessage(request, deps) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.cross_chat_delivery_start",
+        message: "resolving cross-chat delivery",
+        meta: {
+            friendId: request.friendId,
+            channel: request.channel,
+            key: request.key,
+            intent: request.intent,
+            authorizingTrustLevel: request.authorizingSession?.trustLevel ?? null,
+        },
+    });
+    if (request.intent === "generic_outreach") {
+        const result = queueForLater(request, deps, "generic outreach stays queued until the target session is next active");
+        (0, runtime_1.emitNervesEvent)({
+            component: "engine",
+            event: "engine.cross_chat_delivery_end",
+            message: "queued generic outreach for later delivery",
+            meta: {
+                friendId: request.friendId,
+                channel: request.channel,
+                key: request.key,
+                status: result.status,
+            },
+        });
+        return result;
+    }
+    if (!isExplicitlyAuthorized(request)) {
+        const result = {
+            status: "blocked",
+            detail: "explicit cross-chat delivery requires a trusted asking session",
+        };
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "engine",
+            event: "engine.cross_chat_delivery_end",
+            message: "blocked explicit cross-chat delivery",
+            meta: {
+                friendId: request.friendId,
+                channel: request.channel,
+                key: request.key,
+                status: result.status,
+            },
+        });
+        return result;
+    }
+    const deliverer = deps.deliverers?.[request.channel];
+    if (!deliverer) {
+        const result = queueForLater(request, deps, "live delivery unavailable right now; queued for the next active turn");
+        (0, runtime_1.emitNervesEvent)({
+            component: "engine",
+            event: "engine.cross_chat_delivery_end",
+            message: "queued explicit cross-chat delivery because no live deliverer was available",
+            meta: {
+                friendId: request.friendId,
+                channel: request.channel,
+                key: request.key,
+                status: result.status,
+            },
+        });
+        return result;
+    }
+    try {
+        const direct = await deliverer(request);
+        if (direct.status === "delivered_now" || direct.status === "blocked" || direct.status === "failed") {
+            const result = {
+                status: direct.status,
+                detail: direct.detail,
+            };
+            (0, runtime_1.emitNervesEvent)({
+                level: result.status === "failed" ? "error" : result.status === "blocked" ? "warn" : "info",
+                component: "engine",
+                event: "engine.cross_chat_delivery_end",
+                message: "completed direct cross-chat delivery resolution",
+                meta: {
+                    friendId: request.friendId,
+                    channel: request.channel,
+                    key: request.key,
+                    status: result.status,
+                },
+            });
+            return result;
+        }
+        const result = queueForLater(request, deps, direct.detail.trim() || "live delivery unavailable right now; queued for the next active turn");
+        (0, runtime_1.emitNervesEvent)({
+            component: "engine",
+            event: "engine.cross_chat_delivery_end",
+            message: "queued explicit cross-chat delivery after adapter reported unavailability",
+            meta: {
+                friendId: request.friendId,
+                channel: request.channel,
+                key: request.key,
+                status: result.status,
+            },
+        });
+        return result;
+    }
+    catch (error) {
+        const result = {
+            status: "failed",
+            detail: error instanceof Error ? error.message : String(error),
+        };
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "engine",
+            event: "engine.cross_chat_delivery_end",
+            message: "cross-chat delivery threw unexpectedly",
+            meta: {
+                friendId: request.friendId,
+                channel: request.channel,
+                key: request.key,
+                status: result.status,
+                reason: result.detail,
+            },
+        });
+        return result;
+    }
+}

package/dist/heart/daemon/daemon-cli.js

@@ -55,6 +55,7 @@ const specialist_orchestrator_1 = require("./specialist-orchestrator");
 const specialist_prompt_1 = require("./specialist-prompt");
 const specialist_tools_1 = require("./specialist-tools");
 const runtime_metadata_1 = require("./runtime-metadata");
+const runtime_mode_1 = require("./runtime-mode");
 const daemon_runtime_sync_1 = require("./daemon-runtime-sync");
 const agent_discovery_1 = require("./agent-discovery");
 const update_hooks_1 = require("./update-hooks");
@@ -94,6 +95,8 @@ function parseStatusPayload(data) {
         lastUpdated: stringField(overview.lastUpdated) ?? "unknown",
         workerCount: numberField(overview.workerCount) ?? 0,
         senseCount: numberField(overview.senseCount) ?? 0,
+        entryPath: stringField(overview.entryPath) ?? "unknown",
+        mode: stringField(overview.mode) ?? "unknown",
     };
     const parsedSenses = senses.map((entry) => {
         if (!entry || typeof entry !== "object" || Array.isArray(entry))
@@ -174,6 +177,8 @@ function formatDaemonStatusOutput(response, fallback) {
         ["Socket", payload.overview.socketPath],
         ["Version", payload.overview.version],
         ["Last Updated", payload.overview.lastUpdated],
+        ["Entry Path", payload.overview.entryPath],
+        ["Mode", payload.overview.mode],
         ["Workers", String(payload.overview.workerCount)],
         ["Senses", String(payload.overview.senseCount)],
         ["Health", payload.overview.health],
@@ -272,6 +277,7 @@ function formatVersionOutput() {
 }
 function buildStoppedStatusPayload(socketPath) {
     const metadata = (0, runtime_metadata_1.getRuntimeMetadata)();
+    const repoRoot = (0, identity_1.getRepoRoot)();
     return {
         overview: {
             daemon: "stopped",
@@ -281,6 +287,8 @@ function buildStoppedStatusPayload(socketPath) {
             lastUpdated: metadata.lastUpdated,
             workerCount: 0,
             senseCount: 0,
+            entryPath: path.join(repoRoot, "dist", "heart", "daemon", "daemon-entry.js"),
+            mode: (0, runtime_mode_1.detectRuntimeMode)(repoRoot),
         },
         senses: [],
         workers: [],
@@ -729,12 +737,23 @@ function defaultEnsureDaemonBootPersistence(socketPath) {
         homeDir,
     };
     const entryPath = path.join((0, identity_1.getRepoRoot)(), "dist", "heart", "daemon", "daemon-entry.js");
+    /* v8 ignore next -- covered via mock in daemon-cli-defaults.test.ts; v8 on CI attributes the real fs.existsSync branch to the non-mock load @preserve */
+    if (!fs.existsSync(entryPath)) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.entry_path_missing",
+            message: "entryPath does not exist on disk — plist may point to a stale location. Run 'ouro daemon install' from the correct location.",
+            meta: { entryPath },
+        });
+    }
     const logDir = path.join(homeDir, ".agentstate", "daemon", "logs");
     (0, launchd_1.writeLaunchAgentPlist)(launchdDeps, {
         nodePath: process.execPath,
         entryPath,
         socketPath,
         logDir,
+        envPath: process.env.PATH,
     });
 }
 async function defaultInstallSubagents() {

package/dist/heart/daemon/daemon-entry.js

@@ -1,6 +1,41 @@
 #!/usr/bin/env node
 "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 });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 const process_manager_1 = require("./process-manager");
 const daemon_1 = require("./daemon");
 const runtime_1 = require("../../nerves/runtime");
@@ -10,6 +45,8 @@ const task_scheduler_1 = require("./task-scheduler");
 const runtime_logging_1 = require("./runtime-logging");
 const sense_manager_1 = require("./sense-manager");
 const agent_discovery_1 = require("./agent-discovery");
+const identity_1 = require("../identity");
+const runtime_mode_1 = require("./runtime-mode");
 function parseSocketPath(argv) {
     const socketIndex = argv.indexOf("--socket");
     if (socketIndex >= 0) {
@@ -21,11 +58,13 @@ function parseSocketPath(argv) {
 }
 const socketPath = parseSocketPath(process.argv);
 (0, runtime_logging_1.configureDaemonRuntimeLogger)("daemon");
+const entryPath = path.resolve(__dirname, "daemon-entry.js");
+const mode = (0, runtime_mode_1.detectRuntimeMode)((0, identity_1.getRepoRoot)());
 (0, runtime_1.emitNervesEvent)({
     component: "daemon",
     event: "daemon.entry_start",
     message: "starting daemon entrypoint",
-    meta: { socketPath },
+    meta: { socketPath, entryPath, mode },
 });
 const managedAgents = (0, agent_discovery_1.listEnabledBundleAgents)();
 const processManager = new process_manager_1.DaemonProcessManager({
@@ -35,6 +74,7 @@ const processManager = new process_manager_1.DaemonProcessManager({
         channel: "inner-dialog",
         autoStart: true,
     })),
+    existsSync: fs.existsSync,
 });
 const scheduler = new task_scheduler_1.TaskDrivenScheduler({
     agents: [...managedAgents],

package/dist/heart/daemon/daemon.js

@@ -40,6 +40,7 @@ const path = __importStar(require("path"));
 const identity_1 = require("../identity");
 const runtime_1 = require("../../nerves/runtime");
 const runtime_metadata_1 = require("./runtime-metadata");
+const runtime_mode_1 = require("./runtime-mode");
 const update_hooks_1 = require("./update-hooks");
 const bundle_meta_1 = require("./hooks/bundle-meta");
 const bundle_manifest_1 = require("../../mind/bundle-manifest");
@@ -373,6 +374,7 @@ class OuroDaemon {
                 const snapshots = this.processManager.listAgentSnapshots();
                 const workers = buildWorkerRows(snapshots);
                 const senses = this.senseManager?.listSenseRows() ?? [];
+                const repoRoot = (0, identity_1.getRepoRoot)();
                 const data = {
                     overview: {
                         daemon: "running",
@@ -381,6 +383,8 @@ class OuroDaemon {
                         ...(0, runtime_metadata_1.getRuntimeMetadata)(),
                         workerCount: workers.length,
                         senseCount: senses.length,
+                        entryPath: path.join(repoRoot, "dist", "heart", "daemon", "daemon-entry.js"),
+                        mode: (0, runtime_mode_1.detectRuntimeMode)(repoRoot),
                     },
                     workers,
                     senses,

package/dist/heart/daemon/launchd.js

@@ -71,6 +71,9 @@ function generateDaemonPlist(options) {
         `  <key>KeepAlive</key>`,
         `  <true/>`,
     ];
+    if (options.envPath) {
+        lines.push(`  <key>EnvironmentVariables</key>`, `  <dict>`, `    <key>PATH</key>`, `    <string>${options.envPath}</string>`, `  </dict>`);
+    }
     if (options.logDir) {
         lines.push(`  <key>StandardOutPath</key>`, `  <string>${path.join(options.logDir, "ouro-daemon-stdout.log")}</string>`, `  <key>StandardErrorPath</key>`, `  <string>${path.join(options.logDir, "ouro-daemon-stderr.log")}</string>`);
     }

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

@@ -51,6 +51,7 @@ class DaemonProcessManager {
     now;
     setTimeoutFn;
     clearTimeoutFn;
+    existsSyncFn;
     constructor(options) {
         this.maxRestartsPerHour = options.maxRestartsPerHour ?? 10;
         this.stabilityThresholdMs = options.stabilityThresholdMs ?? 60_000;
@@ -60,6 +61,7 @@ class DaemonProcessManager {
         this.now = options.now ?? (() => Date.now());
         this.setTimeoutFn = options.setTimeoutFn ?? ((cb, delay) => setTimeout(cb, delay));
         this.clearTimeoutFn = options.clearTimeoutFn ?? ((timer) => clearTimeout(timer));
+        this.existsSyncFn = options.existsSync ?? null;
         for (const agent of options.agents) {
             this.agents.set(agent.name, {
                 config: agent,
@@ -96,6 +98,17 @@ class DaemonProcessManager {
         state.snapshot.status = "starting";
         const runCwd = (0, identity_1.getRepoRoot)();
         const entryScript = path.join((0, identity_1.getRepoRoot)(), "dist", state.config.entry);
+        if (this.existsSyncFn && !this.existsSyncFn(entryScript)) {
+            state.snapshot.status = "crashed";
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "daemon",
+                event: "daemon.agent_entry_missing",
+                message: "agent entry script does not exist — cannot spawn. Run 'ouro daemon install' from the correct location.",
+                meta: { agent, entryScript },
+            });
+            return;
+        }
         const args = [entryScript, "--agent", state.config.agentArg ?? agent, ...(state.config.args ?? [])];
         const child = this.spawnFn("node", args, {
             cwd: runCwd,

package/dist/heart/daemon/runtime-mode.js

@@ -0,0 +1,67 @@
+"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.detectRuntimeMode = detectRuntimeMode;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+function detectRuntimeMode(rootPath, deps = {}) {
+    const checkExists = deps.existsSync ?? fs.existsSync;
+    // 1. Production: installed via npm
+    if (rootPath.includes("node_modules/@ouro.bot/cli") ||
+        rootPath.includes("node_modules/ouro.bot")) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.runtime_mode_detected",
+            message: "detected runtime mode",
+            meta: { rootPath, mode: "production" },
+        });
+        return "production";
+    }
+    // 2-4. Everything else is dev: worktrees, git repos, unknown paths
+    // (conservative default: assume dev unless proven production)
+    const reason = rootPath.includes(".claude/worktrees/")
+        ? "worktree"
+        : checkExists(path.join(rootPath, ".git"))
+            ? "git-repo"
+            : "unknown";
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.runtime_mode_detected",
+        message: "detected runtime mode",
+        meta: { rootPath, mode: "dev", reason },
+    });
+    return "dev";
+}

package/dist/heart/target-resolution.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listTargetSessionCandidates = listTargetSessionCandidates;
+exports.formatTargetSessionCandidates = formatTargetSessionCandidates;
+const session_recall_1 = require("./session-recall");
+const session_activity_1 = require("./session-activity");
+const trust_explanation_1 = require("../mind/friends/trust-explanation");
+const runtime_1 = require("../nerves/runtime");
+function synthesizeFriendRecord(candidate) {
+    return {
+        id: candidate.friendId,
+        name: candidate.friendName,
+        role: "stranger",
+        trustLevel: "stranger",
+        connections: [],
+        externalIds: [],
+        tenantMemberships: [],
+        toolPreferences: {},
+        notes: {},
+        totalTokens: 0,
+        createdAt: new Date(0).toISOString(),
+        updatedAt: new Date(0).toISOString(),
+        schemaVersion: 1,
+    };
+}
+function deliveryPriority(mode) {
+    if (mode === "deliver_now")
+        return 0;
+    if (mode === "queue_only")
+        return 1;
+    return 2;
+}
+function activityPriority(source) {
+    return source === "friend-facing" ? 0 : 1;
+}
+function describeDelivery(candidate) {
+    if (candidate.channel !== "bluebubbles" && candidate.channel !== "teams") {
+        return { mode: "blocked", reason: "this channel does not support proactive outward delivery yet" };
+    }
+    if (candidate.trust.level === "family" || candidate.trust.level === "friend") {
+        return { mode: "deliver_now", reason: "directly trusted target on a proactive-delivery channel" };
+    }
+    return { mode: "queue_only", reason: "visible as a live chat, but immediate delivery still needs explicit cross-chat authorization" };
+}
+async function listTargetSessionCandidates(input) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.target_resolution_start",
+        message: "listing live target session candidates",
+        meta: {
+            sessionsDir: input.sessionsDir,
+            currentSession: input.currentSession
+                ? `${input.currentSession.friendId}/${input.currentSession.channel}/${input.currentSession.key}`
+                : null,
+        },
+    });
+    const activity = (0, session_activity_1.listSessionActivity)({
+        sessionsDir: input.sessionsDir,
+        friendsDir: input.friendsDir,
+        agentName: input.agentName,
+        currentSession: input.currentSession ?? null,
+    }).filter((entry) => entry.channel !== "inner");
+    const candidates = [];
+    for (const entry of activity) {
+        const friend = await input.friendStore.get(entry.friendId) ?? synthesizeFriendRecord(entry);
+        const trust = (0, trust_explanation_1.describeTrustContext)({
+            friend,
+            channel: entry.channel,
+        });
+        const recall = await (0, session_recall_1.recallSession)({
+            sessionPath: entry.sessionPath,
+            friendId: entry.friendId,
+            channel: entry.channel,
+            key: entry.key,
+            messageCount: 6,
+            summarize: input.summarize,
+            trustLevel: trust.level,
+        });
+        const snapshot = recall.kind === "ok"
+            ? recall.snapshot
+            : recall.kind === "empty"
+                ? "recent focus: no recent visible messages"
+                : "recent focus: session transcript unavailable";
+        const delivery = describeDelivery({
+            channel: entry.channel,
+            trust,
+        });
+        candidates.push({
+            friendId: entry.friendId,
+            friendName: entry.friendName,
+            channel: entry.channel,
+            key: entry.key,
+            sessionPath: entry.sessionPath,
+            snapshot,
+            trust,
+            delivery,
+            lastActivityAt: entry.lastActivityAt,
+            lastActivityMs: entry.lastActivityMs,
+            activitySource: entry.activitySource,
+        });
+    }
+    return candidates.sort((a, b) => {
+        const deliveryDiff = deliveryPriority(a.delivery.mode) - deliveryPriority(b.delivery.mode);
+        if (deliveryDiff !== 0)
+            return deliveryDiff;
+        const sourceDiff = activityPriority(a.activitySource) - activityPriority(b.activitySource);
+        if (sourceDiff !== 0)
+            return sourceDiff;
+        return b.lastActivityMs - a.lastActivityMs;
+    });
+}
+function formatTargetSessionCandidates(candidates) {
+    if (candidates.length === 0)
+        return "";
+    const lines = ["## candidate target chats"];
+    for (const candidate of candidates) {
+        lines.push(`- ${candidate.friendName} [${candidate.friendId}] via ${candidate.channel}/${candidate.key}`);
+        lines.push(`  trust: ${candidate.trust.level} (${candidate.trust.basis}) — ${candidate.trust.summary}`);
+        lines.push(`  delivery: ${candidate.delivery.mode} — ${candidate.delivery.reason}`);
+        lines.push(`  snapshot: ${candidate.snapshot}`);
+    }
+    return lines.join("\n");
+}