@cello-protocol/daemon 0.0.30 → 0.0.32

package/dist/daemon.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"daemon.d.ts","sourceRoot":"","sources":["../src/daemon.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAKH,OAAO,KAAK,EACV,YAAY,EACZ,oBAAoB,EASrB,MAAM,YAAY,CAAC;AAIpB,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAM/D,OAAO,EAAoD,KAAK,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAsB7G,OAAO,KAAK,EAAE,kBAAkB,EAA+C,MAAM,yBAAyB,CAAC;AAO/G,OAAO,EAAoB,KAAK,eAAe,EAAE,MAAM,2BAA2B,CAAC;AA0InF,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpC,SAAS,IAAI,oBAAoB,CAAC;IAClC;;;;OAIG;IACH,qBAAqB,IAAI,kBAAkB,CAAC;IAC5C;;;;;;;;OAQG;IACH,gBAAgB,IAAI,SAAS,GAAG,IAAI,CAAC;IACrC;;;;OAIG;IACH,oBAAoB,IAAI,kBAAkB,CAAC;IAC3C;;;OAGG;IACH,iBAAiB,IAAI,eAAe,CAAC;CACtC;AAyCD,wBAAsB,WAAW,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAmkJ7E"}
+{"version":3,"file":"daemon.d.ts","sourceRoot":"","sources":["../src/daemon.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAKH,OAAO,KAAK,EACV,YAAY,EACZ,oBAAoB,EASrB,MAAM,YAAY,CAAC;AAIpB,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAM/D,OAAO,EAAoD,KAAK,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAsB7G,OAAO,KAAK,EAAE,kBAAkB,EAA+C,MAAM,yBAAyB,CAAC;AAO/G,OAAO,EAAoB,KAAK,eAAe,EAAE,MAAM,2BAA2B,CAAC;AA0InF,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpC,SAAS,IAAI,oBAAoB,CAAC;IAClC;;;;OAIG;IACH,qBAAqB,IAAI,kBAAkB,CAAC;IAC5C;;;;;;;;OAQG;IACH,gBAAgB,IAAI,SAAS,GAAG,IAAI,CAAC;IACrC;;;;OAIG;IACH,oBAAoB,IAAI,kBAAkB,CAAC;IAC3C;;;OAGG;IACH,iBAAiB,IAAI,eAAe,CAAC;CACtC;AAyCD,wBAAsB,WAAW,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CA0wJ7E"}

package/dist/daemon.js

@@ -1254,19 +1254,16 @@ export async function startDaemon(config) {
         return agents
             .filter((a) => a.state !== "load_failed")
             .map((a) => {
-            let state;
-            if (a.name === currentAgent && onlineAgents.has(a.name)) {
-                state = "current";
-            }
-            else if (onlineAgents.has(a.name)) {
-                state = "online";
-            }
-            else {
-                state = "registered";
-            }
+            // M8C-AUTOSTART-1 (F5): `state` reports readiness only (online vs registered); selection
+            // is a SEPARATE `selected` flag. Previously `state = "current"` overloaded the current
+            // agent, making it read as a different readiness level than a second healthy online agent.
+            const online = onlineAgents.has(a.name);
+            const state = online ? "online" : "registered";
+            const selected = online && a.name === currentAgent;
             return {
                 name: a.name,
                 state,
+                selected,
                 pubkey: a.pubkey,
                 // M8B F14 (fix 5): per-agent standing-receiver readiness on the MCP surface
                 // (cello_status / cello_list_agents), so a deaf agent is visible to the operator.
@@ -1348,11 +1345,13 @@ export async function startDaemon(config) {
         return { connectionId };
     });
     // ─── MCP-001: cello_start_agent handler ───
-    handlers.set("cello_start_agent", async (params, _connectionId) => {
-        const name = params?.name;
-        if (!name) {
-            return { ok: false, reason: "missing_params", guidance: "Provide 'name' parameter with the agent name to start." };
-        }
+    // M8C-AUTOSTART-1 (A2): the shared start path. Extracted from cello_start_agent so cello_use_agent
+    // can AUTO-START an offline agent through the exact same code (idempotent, same signaling +
+    // standing-receiver setup, same agent_state_changed event) — never a divergent shim-side retry.
+    // Permissive by design (D12): an agent that exists goes online regardless of directory
+    // registration state (online-without-registration is an established contract). Returns a
+    // structured failure so callers can surface agent_start_failed with a real reason + guidance.
+    function startAgentInternal(name) {
         const agent = agents.find((a) => a.name === name);
         if (!agent || agent.state === "load_failed") {
             return { ok: false, reason: "agent_not_found", guidance: `Agent '${name}' does not exist. Run 'cello login' to register agents, or check agent names with cello_list_agents.` };
@@ -1397,6 +1396,29 @@ export async function startDaemon(config) {
         // MCP-002: Broadcast agent_state_changed to ALL connections
         notificationDispatcher.dispatchAgentStateChanged(name, "online", "started");
         return { ok: true };
+    }
+    // M8C-AUTOSTART-1 (F18): resolve which agent a name-defaulting tool should act on for this
+    // connection: an explicit name wins; else the connection's current agent; else — when EXACTLY one
+    // agent is online daemon-wide — that sole agent (removes the "why did it forget my agent" moment
+    // after a /mcp reconnect). Two-or-more online with none selected stays ambiguous → null (the
+    // caller returns no_current_agent), because guessing between peers would misroute.
+    function resolveCurrentAgent(connState, explicitName) {
+        if (explicitName)
+            return explicitName;
+        if (connState?.currentAgent)
+            return connState.currentAgent;
+        if (onlineAgents.size === 1)
+            return [...onlineAgents][0];
+        return null;
+    }
+    // ─── MCP-001: cello_start_agent handler ───
+    // Bring a registered agent online WITHOUT claiming it as this connection's current agent.
+    handlers.set("cello_start_agent", async (params, _connectionId) => {
+        const name = params?.name;
+        if (!name) {
+            return { ok: false, reason: "missing_params", guidance: "Provide 'name' parameter with the agent name to start." };
+        }
+        return startAgentInternal(name);
     });
     // ─── PERSIST-002 (AC-004): cello_create_agent handler ───
     // The explicit agent-creation path: generate a fresh K_local seed, write it as an `agents` row in
@@ -1648,15 +1670,36 @@ export async function startDaemon(config) {
         }
         const agent = agents.find((a) => a.name === name);
         if (!agent || agent.state === "load_failed") {
-            return { ok: false, reason: "agent_not_found", guidance: `Agent '${name}' does not exist. Check agent names with cello_list_agents.` };
-        }
-        if (!onlineAgents.has(name)) {
-            return { ok: false, reason: "agent_not_online", guidance: `Agent '${name}' exists but is not online. Call cello_start_agent('${name}') first to bring it online, then retry cello_use_agent.` };
+            return { ok: false, reason: "agent_not_found", guidance: `Agent '${name}' does not exist. Create it with 'cello create-agent ${name}', register it, then retry — or check names with cello_list_agents.` };
         }
         const connState = perConnectionState.get(connectionId);
         if (!connState) {
             return { ok: false, reason: "connection_not_registered", guidance: "Send ipc.connect frame before calling agent tools." };
         }
+        // M8C-AUTOSTART-1 (A1): auto-start the agent if it is not online, so the incantation collapses
+        // to `login → use_agent` (no separate cello_start_agent). On a start failure, return a
+        // structured agent_start_failed and leave the current selection UNCHANGED — no half-selected
+        // state (A3). cello_start_agent stays available for bring-online-without-claiming.
+        if (!onlineAgents.has(name)) {
+            logger.info("agent.autostart.attempted", { connectionId, agentName: name });
+            const startRes = startAgentInternal(name);
+            if (!startRes.ok) {
+                // Structured failure envelope (D6). Today `startAgentInternal` is permissive (D12) and its
+                // only failure — agent_not_found — is already caught by the existence pre-check above, so
+                // this branch is currently unreachable. It is the RESERVED structured-failure surface for
+                // when auto-start gains a synchronous failure mode (e.g. D12's reverse: a bounded
+                // waitForSignalingConnected making `directory_unreachable` a real start failure). Kept so
+                // that extension surfaces the reason + guidance here with the selection left unchanged.
+                // See M8C-DECISIONS D12 + BUILD-JOURNAL Entry 8.
+                logger.warn("agent.autostart.failed", { connectionId, agentName: name, reason: startRes.reason });
+                return {
+                    ok: false,
+                    reason: "agent_start_failed",
+                    start_reason: startRes.reason,
+                    guidance: `Could not start agent '${name}' to select it: ${startRes.guidance} Your current agent is unchanged.`,
+                };
+            }
+        }
         if (connState.currentAgent === name) {
             return { ok: false, reason: "agent_already_current", guidance: `Agent '${name}' is already the current agent for this connection. No action needed — you can proceed with session operations.` };
         }
@@ -1666,7 +1709,26 @@ export async function startDaemon(config) {
         notificationDispatcher.setCurrentAgent(connectionId, name);
         notificationDispatcher.dispatchAgentCurrentChanged(connectionId, fromAgent, name);
         logger.info("agent.current.switched", { connectionId, fromAgent, toAgent: name });
-        return { ok: true };
+        // M8C-AUTOSTART-1 (A3, D12): not_registered is a NON-BLOCKING warning — the agent is selected
+        // and usable locally, but it cannot establish directory sessions until registered. Surface the
+        // next step (ONBOARD-NEXTSTEP style) without stranding the selection. One-row read.
+        const result = { ok: true };
+        try {
+            const reg = await new DbRegistrationPersistence({ db: sessionNodeManager.getDb(), agentName: name, logger }).loadRegistrationState();
+            if (!reg || reg.status !== "active") {
+                result["warning"] = "not_registered";
+                result["warning_guidance"] = `Agent '${name}' is now selected but is not registered with the directory — run 'cello register ${name}' to enable sessions with peers. Run 'cello status' to watch registration complete.`;
+            }
+        }
+        catch (err) {
+            // A failed registration read must not break selection (the agent IS selected). Log the real
+            // reason, and surface a softer `registration_unknown` warning so the operator's surface is NOT
+            // falsely clean — we could not confirm registration, so don't imply it is fine (Finding 3).
+            logger.warn("agent.registration.read.failed", { agentName: name, reason: err instanceof Error ? err.message : String(err) });
+            result["warning"] = "registration_unknown";
+            result["warning_guidance"] = `Agent '${name}' is selected, but its registration status could not be read — run 'cello status' to check whether it is registered with the directory.`;
+        }
+        return result;
     });
     // ─── MCP-001: cello_list_agents handler ───
     handlers.set("cello_list_agents", async (_params, connectionId) => {
@@ -2304,7 +2366,7 @@ export async function startDaemon(config) {
     // ─── M8B DOD-REFRESH-1: cello_refresh_shares — proactive share refresh / epoch rollover ───
     handlers.set("cello_refresh_shares", async (params, connectionId) => {
         const connState = perConnectionState.get(connectionId);
-        const agentName = params?.name ?? connState?.currentAgent;
+        const agentName = resolveCurrentAgent(connState, params?.name); // M8C-AUTOSTART-1 F18: sole-online fallback
         if (!agentName) {
             return { ok: false, reason: "no_current_agent", guidance: "Select an agent with cello_use_agent, or pass { name }." };
         }
@@ -2336,7 +2398,7 @@ export async function startDaemon(config) {
     // ─── M8B DOD-RELAYSIG-1: cello_get_relay_receipts — the agent's stored relay ordering receipts ───
     handlers.set("cello_get_relay_receipts", async (params, connectionId) => {
         const connState = perConnectionState.get(connectionId);
-        const agentName = params?.name ?? connState?.currentAgent;
+        const agentName = resolveCurrentAgent(connState, params?.name); // M8C-AUTOSTART-1 F18: sole-online fallback
         if (!agentName) {
             return { ok: false, reason: "no_current_agent", guidance: "Select an agent with cello_use_agent, or pass { name }." };
         }
@@ -2845,15 +2907,47 @@ export async function startDaemon(config) {
         if (!connState || !connState.currentAgent) {
             return NO_CURRENT_AGENT_RESPONSE;
         }
-        const cert = sessionNodeManager.getSealCertificate(connState.currentAgent, sessionId);
-        if (!cert) {
+        const agentName = connState.currentAgent;
+        const cert = sessionNodeManager.getSealCertificate(agentName, sessionId);
+        if (cert) {
+            return { ok: true, session_id: sessionId, sealed_root: cert.sealed_root, legibility: cert.legibility };
+        }
+        // M8C-INBOX-1 (F4): the single `sealed_receipt_not_found` conflated four distinct causes, so a
+        // caller could not tell a typo from a not-sealed-yet session from a wrong-agent selection.
+        // Split them (full session ids on cello_list_sessions / cello_status already let a pasted id match).
+        if (sessionNodeManager.getSessionRecord(agentName, sessionId)) {
+            // The session is THIS agent's — it simply has no seal certificate yet.
             return {
                 ok: false,
-                reason: "sealed_receipt_not_found",
-                guidance: "No sealed certificate is recorded for this session. It may not be sealed yet, or the session_id is wrong — close it with cello_close_session and confirm it reports sealed, then retry.",
+                reason: "not_sealed_yet",
+                guidance: "This session exists but is not sealed yet. Close it with cello_close_session and confirm it reports sealed (or wait for the counterparty to co-seal), then retry.",
             };
         }
-        return { ok: true, session_id: sessionId, sealed_root: cert.sealed_root, legibility: cert.legibility };
+        // Owned by a DIFFERENT loaded agent → the caller has the wrong current agent selected.
+        const owner = loadedAgents.find((a) => a.name !== agentName && sessionNodeManager.getSessionRecord(a.name, sessionId));
+        if (owner) {
+            return {
+                ok: false,
+                reason: "wrong_agent",
+                guidance: `This session belongs to agent '${owner.name}', not the current agent '${agentName}'. Call cello_use_agent('${owner.name}') then retry cello_get_sealed_receipt.`,
+            };
+        }
+        // A truncated paste: the id is a strict prefix of one of this agent's real session ids.
+        const truncated = sessionNodeManager
+            .getSessionsForAgent(agentName)
+            .some((s) => s.session_id.startsWith(sessionId) && s.session_id.length > sessionId.length);
+        if (truncated) {
+            return {
+                ok: false,
+                reason: "session_id_too_short",
+                guidance: "That looks like a truncated session id. cello_list_sessions and cello status show the FULL id — copy the complete id and retry.",
+            };
+        }
+        return {
+            ok: false,
+            reason: "unknown_session",
+            guidance: "No session with this id belongs to the current agent. Run cello_list_sessions to see the full ids of this agent's sessions.",
+        };
     });
     // DOD-LOG-1 (PERSIST-LOG-001): read the durable, decrypted conversation transcript for a session —
     // the readable sent+received messages in canonical-sequence order, recovered AFTER a daemon restart
@@ -3200,6 +3294,32 @@ export async function startDaemon(config) {
             }
             return { ok: true };
         });
+        // M8C-INBOX-1: test hook to enqueue a pending inbound session request (mirrors the real inbound
+        // flow's enqueueInboundSession) so cello_check_notifications' pending_session_requests is testable
+        // without standing up the full libp2p inbound path.
+        handlers.set("__test_enqueue_inbound_session", async (params, _connectionId) => {
+            const agentName = params?.agentName;
+            const sessionIdHex = params?.sessionId;
+            const counterpartyPubkeyHex = params?.counterpartyPubkey ?? "";
+            if (!agentName || !sessionIdHex) {
+                return { error: "missing_params", guidance: "Provide agentName and sessionId." };
+            }
+            enqueueInboundSession(agentName, { sessionIdHex, counterpartyPubkeyHex, genesisPrevRootHex: "" });
+            return { ok: true };
+        });
+        // M8C-INBOX-1 (reviewer F1): buffer a received message so a test can drive a live cello_receive
+        // and assert the watermark advances (the N3 delivery-marks-read coupling), without a session tree.
+        handlers.set("__test_buffer_received", async (params, _connectionId) => {
+            const agentName = params?.agentName;
+            const sessionId = params?.sessionId;
+            const seq = params?.seq;
+            const content = params?.content ?? "hello";
+            if (!agentName || !sessionId || typeof seq !== "number") {
+                return { error: "missing_params", guidance: "Provide agentName, sessionId, seq." };
+            }
+            sessionNodeManager.pushReceivedContentForTest(agentName, sessionId, seq, content, params?.senderPubkey ?? "cp");
+            return { ok: true };
+        });
     } // end CELLO_ENV=test guard
     // ─── M7-SESSION-001 (H-1): seal-interrupted bilateral RESPONDER ────────────
     //
@@ -4298,6 +4418,30 @@ export async function startDaemon(config) {
         if (record.agent_name !== agentName) {
             return { ok: false, reason: "session_not_owned", guidance: "This session belongs to a different agent. Call cello_use_agent to switch to the agent that owns it, then retry." };
         }
+        // M8C-SINCESEQ-1: stateless catch-up. When since_seq is provided, return a BATCH of received
+        // transcript messages with sequence > since_seq (durable transcript, not the ephemeral buffer —
+        // so concurrent arrivals don't shift what a given since_seq returns; no replay race). Replaces
+        // the cello_get_transcript workaround for away-then-return. Received-direction only (the messages
+        // you'd have gotten live). Advances the read watermark (delivery marks read — clears INBOX
+        // unread). A distinct early branch: the plain (no since_seq) receive is entirely unchanged.
+        const rawSince = params?.since_seq;
+        if (typeof rawSince === "number" && Number.isFinite(rawSince)) {
+            const sinceSeq = rawSince;
+            const from = record.counterparty_pubkey;
+            const { messages } = sessionNodeManager.readTranscript(agentName, sessionId);
+            const received = messages.filter((m) => m.direction === "received" && m.sequence > sinceSeq);
+            if (received.length > 0) {
+                // readTranscript is ordered by sequence ASC → the last is the max.
+                sessionNodeManager.advanceLastDeliveredSeq(agentName, sessionId, received[received.length - 1].sequence);
+            }
+            logger.info("session.receive.since_seq", { sessionId, agentName, since_seq: sinceSeq, count: received.length });
+            return {
+                ok: true,
+                since_seq: sinceSeq,
+                count: received.length,
+                messages: received.map((m) => ({ sequence: m.sequence, content: m.text, from })),
+            };
+        }
         const rawTimeout = params?.timeout_ms;
         const timeoutMs = typeof rawTimeout === "number" && Number.isFinite(rawTimeout) && rawTimeout >= 0
             ? rawTimeout
@@ -4307,6 +4451,9 @@ export async function startDaemon(config) {
             // 1) Deliverable content wins — drain one buffered message per call (FIFO).
             const entry = sessionNodeManager.takeReceivedContent(agentName, sessionId);
             if (entry) {
+                // M8C-INBOX-1 (N3): delivery marks read — advance the persisted read watermark so this
+                // message no longer counts as unread in cello_check_notifications. Monotonic (never lowers).
+                sessionNodeManager.advanceLastDeliveredSeq(agentName, sessionId, entry.sequenceNumber);
                 return {
                     ok: true,
                     content: Buffer.from(entry.contentHex, "hex").toString("utf8"),
@@ -4354,6 +4501,45 @@ export async function startDaemon(config) {
     };
     handlers.set("cello_receive", handleReceive);
     handlers.set("cello_receive_session", handleReceive);
+    // ─── M8C-INBOX-1 (N1/N4): cello_check_notifications — push-loss reconciler + poll-only inbox ───
+    // Notifications are fire-and-forget (no ack, no redelivery); this is how a client discovers what
+    // it missed while its shim was down/busy, and the primary inbox for poll-only clients (Bedrock,
+    // cron). Content-free: pending session requests (from the in-memory queue, READ non-destructively —
+    // cello_await_session owns draining) + unread message counts (derived from the persisted read
+    // watermark, N2). No separate notification store; no ack verb (N4).
+    handlers.set("cello_check_notifications", async (params, connectionId) => {
+        const connState = perConnectionState.get(connectionId);
+        const scope = params?.scope === "all" ? "all" : "current";
+        let agentNames;
+        if (scope === "all") {
+            agentNames = loadedAgents.map((a) => a.name);
+        }
+        else {
+            // F18: an explicit current agent, else the sole-online agent; ambiguous → no_current_agent.
+            const current = resolveCurrentAgent(connState);
+            if (!current) {
+                return {
+                    ok: false,
+                    reason: "no_current_agent",
+                    guidance: "No current agent for this connection. Call cello_use_agent to select one, or use scope:\"all\" to check every loaded agent.",
+                };
+            }
+            agentNames = [current];
+        }
+        const agents = agentNames.map((agent) => {
+            const pending = (inboundSessionQueues.get(agent) ?? []).map((e) => ({
+                session_id: e.sessionIdHex,
+                from: e.counterpartyPubkeyHex,
+            }));
+            const unread = sessionNodeManager.getUnreadSummary(agent);
+            const total_unread = unread.reduce((sum, u) => sum + u.unread_count, 0);
+            return { agent, pending_session_requests: pending, unread, total_unread };
+        });
+        const totalUnread = agents.reduce((sum, a) => sum + a.total_unread, 0);
+        const totalPending = agents.reduce((sum, a) => sum + a.pending_session_requests.length, 0);
+        logger.info("inbox.checked", { connectionId, scope, agentCount: agents.length, totalUnread, totalPending });
+        return { ok: true, scope, agents };
+    });
     let shutdownPromise = null;
     handlers.set("shutdown", async (_params, _connectionId) => {
         if (!shutdownPromise) {
@@ -4389,6 +4575,12 @@ export async function startDaemon(config) {
     sessionNodeManager.setOnSessionStateChanged((agentName, sessionId, state, counterpartyPubkey) => {
         notificationDispatcher.dispatchSessionStateChanged(agentName, sessionId, state, counterpartyPubkey);
     });
+    // M8C-MSGWAKE-1 (channel stage 2): per-message wake — a verified inbound message fires a
+    // content-free `cello_message` doorbell to the current-agent connection(s). The shim's generic
+    // bridge (WAKE) forwards it to a live --channels session as notifications/claude/channel.
+    sessionNodeManager.setOnContentArrived((agentName, sessionId, senderPubkey) => {
+        notificationDispatcher.dispatchCelloMessage(agentName, sessionId, senderPubkey);
+    });
     // MCP-001: Clean up per-connection state when a connection disconnects
     // MCP-002: Also unregister from notification dispatcher
     ipcServer.onDisconnect((connectionId) => {