@cello-protocol/daemon 0.0.13 → 0.0.15

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,EAMrB,MAAM,YAAY,CAAC;AAIpB,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAK/D,OAAO,EAAoD,KAAK,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAoB7G,OAAO,KAAK,EAAE,kBAAkB,EAA+C,MAAM,yBAAyB,CAAC;AAM/G,OAAO,EAAoB,KAAK,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAqInF,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,CAgoH7E"}
+{"version":3,"file":"daemon.d.ts","sourceRoot":"","sources":["../src/daemon.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAKH,OAAO,KAAK,EACV,YAAY,EACZ,oBAAoB,EAQrB,MAAM,YAAY,CAAC;AAIpB,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAM/D,OAAO,EAAoD,KAAK,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAoB7G,OAAO,KAAK,EAAE,kBAAkB,EAA+C,MAAM,yBAAyB,CAAC;AAM/G,OAAO,EAAoB,KAAK,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAqInF,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,CA8vH7E"}

package/dist/daemon.js

@@ -32,6 +32,7 @@ import { loadAgents } from "./agent-loader.js";
 import { acquireLock, removeLock } from "./lock-file.js";
 import { createIpcServer } from "./ipc-server.js";
 import { SessionNodeManager } from "./session-node-manager.js";
+import { classifySession } from "./session-category.js";
 import { RetryQueue } from "./retry-queue.js";
 import { NonceDedupStore } from "./nonce-dedup.js";
 import { ContentParkClient } from "./content-park-client.js";
@@ -42,7 +43,7 @@ import { RegistrationManager } from "./registration-manager.js";
 import { DaemonRegistrationContext } from "./registration-context.js";
 import { DbRegistrationPersistence, DbIdentityStore } from "./db-identity-store.js";
 import { DbManifestVersionStore } from "./manifest-version-store-db.js";
-import { verify as ed25519Verify, sealToRecipient, generateKLocalSeed, InMemoryKeyProvider } from "@cello-protocol/crypto";
+import { verify as ed25519Verify, sealToRecipient, generateKLocalSeed, InMemoryKeyProvider, hash as cryptoHash } from "@cello-protocol/crypto";
 import { attemptSealUpgrade as attemptSealUpgradeImpl, verifyUpgradeConfirmedCert } from "./seal-upgrade.js";
 // CELLO-M7-MSG-001 (AC-013/AC-018): the single application content-size cap, enforced
 // at the send point here (the receive point lives in the transport content decode).
@@ -468,6 +469,15 @@ export async function startDaemon(config) {
             signaling: mgr,
             logger,
         });
+        // CELLO-M8-TRUST-001: receive sealed trust signals pushed from the directory pickup queue on
+        // THIS agent's stream. Open with k_local, verify the recomputed hash against the directory
+        // anchor, store locally, then ACK (so the directory deletes the ciphertext). The daemon is the
+        // ONLY party that can open the seal (SI-001); a hash mismatch is rejected without storing/ACKing.
+        mgr.registerInboundHandler((frame) => {
+            if (frame["type"] !== "trust_signal_pickup")
+                return;
+            void handleTrustSignalPickup(frame, agentKeyProvider, mgr, agentName);
+        });
         // CELLO-M7-CONN-001 (DOD-CONN-2): inbound session_assignment + seal_interrupted_request
         // on THIS agent's own stream, so a non-primary agent receives inbound sessions (SPINE-5).
         wirePerAgentSessionInbound(mgr);
@@ -902,9 +912,18 @@ export async function startDaemon(config) {
     // array from SQLite. Shared by both getStatus() (daemon-wide) and the
     // cello_status MCP handler (per-connection) so live MCP clients see the same
     // interrupted sessions a CLI `cello status` would.
+    // `cello status` is a health snapshot, not a session archive. It surfaces ONLY genuinely
+    // RESUMABLE sessions (interrupted with messages exchanged) — never failed inits (interrupted,
+    // 0 messages — a dead handshake), which classify as "failed" and would otherwise accumulate
+    // unbounded and confuse. The list is also capped; the full, queryable history is `cello sessions`
+    // / cello_list_sessions (with filter + limit flags).
+    const STATUS_RESUMABLE_CAP = 10;
     function buildInterruptedSessions() {
-        const interruptedRows = sessionNodeManager.getSessionsByStatus("interrupted");
-        return interruptedRows.map((row) => ({
+        return sessionNodeManager
+            .getSessionsByStatus("interrupted")
+            .filter((row) => (row.message_count ?? 0) > 0) // resumable only — drop failed 0-message inits
+            .slice(0, STATUS_RESUMABLE_CAP)
+            .map((row) => ({
             sessionId: row.session_id,
             agentName: row.agent_name,
             counterpartyPubkey: row.counterparty_pubkey,
@@ -2114,27 +2133,56 @@ export async function startDaemon(config) {
     // and the guidance strings that point here ("See cello_list_sessions") dead-end.
     // Read from the persisted SQLite store, so it works after a daemon restart and
     // from a fresh MCP connection (no in-memory session-node required).
-    handlers.set("cello_list_sessions", async (_params, connectionId) => {
-        const connState = perConnectionState.get(connectionId);
-        if (!connState || !connState.currentAgent) {
-            return NO_CURRENT_AGENT_RESPONSE;
-        }
-        const agentName = connState.currentAgent;
-        const sessions = sessionNodeManager
-            .getSessionsForAgent(agentName)
-            .map((row) => ({
+    // Classify → filter → cap a set of session rows into a SessionListResponse. Shared by the
+    // per-agent MCP surface (cello_list_sessions) and the daemon-wide CLI surface (list_sessions),
+    // so the operator-facing categories (open/closed/failed) and the default cap never drift.
+    // Default filter = "open" (live/resumable only — the common case); default limit bounds the
+    // response so a long-lived agent's history can't balloon it. `all` includes failed/closed.
+    const DEFAULT_LIST_LIMIT = 50;
+    const MAX_LIST_LIMIT = 500;
+    function selectSessions(rows, params) {
+        const rawFilter = typeof params?.filter === "string" ? params.filter : "open";
+        const filter = rawFilter === "closed" || rawFilter === "failed" || rawFilter === "all" ? rawFilter : "open";
+        let limit = Number(params?.limit);
+        if (!Number.isFinite(limit) || limit < 1)
+            limit = DEFAULT_LIST_LIMIT;
+        limit = Math.min(Math.floor(limit), MAX_LIST_LIMIT);
+        const classified = rows.map((row) => {
+            const messageCount = row.message_count ?? 0;
+            const category = classifySession(row.status, messageCount);
+            return { row, messageCount, category };
+        });
+        const matched = filter === "all" ? classified : classified.filter((c) => c.category === filter);
+        const sessions = matched.slice(0, limit).map(({ row, messageCount, category }) => ({
             sessionId: row.session_id,
             agentName: row.agent_name,
             counterpartyPubkey: row.counterparty_pubkey,
             status: row.status,
-            messageCount: row.message_count ?? 0,
+            category,
+            messageCount,
             createdAt: new Date(row.created_at).toISOString(),
             updatedAt: new Date(row.updated_at).toISOString(),
             // interrupted_at is the canonical ISO interruption stamp; null for any
             // session that was never interrupted (active/sealed).
             interruptedAt: row.interrupted_at ?? null,
         }));
-        return { ok: true, sessions };
+        return { ok: true, filter, limit, totalMatched: matched.length, sessions };
+    }
+    // cello_list_sessions (MCP, per current agent): the discovery surface for the by-id reads
+    // (cello_get_transcript / cello_get_sealed_receipt). Accepts { filter?: open|closed|failed|all,
+    // limit?: number } — defaults to open + DEFAULT_LIST_LIMIT so failed/dead handshakes don't drown
+    // the live ones. Read from persisted SQLite, so it survives a daemon restart / fresh connection.
+    handlers.set("cello_list_sessions", async (params, connectionId) => {
+        const connState = perConnectionState.get(connectionId);
+        if (!connState || !connState.currentAgent) {
+            return NO_CURRENT_AGENT_RESPONSE;
+        }
+        return selectSessions(sessionNodeManager.getSessionsForAgent(connState.currentAgent), params);
+    });
+    // list_sessions (daemon-wide, for the `cello sessions` CLI which has no current agent): same
+    // filter/limit semantics, across ALL agents.
+    handlers.set("list_sessions", async (params) => {
+        return selectSessions(sessionNodeManager.getAllSessions(), params);
     });
     // DAEMON-003 IPC handlers: queue_failed_send and check_nonce (AC-010)
     handlers.set("queue_failed_send", async (params, _connectionId) => {
@@ -2852,6 +2900,68 @@ export async function startDaemon(config) {
     // the keystone) received them. A frame arrives on exactly one agent's stream, so there is no
     // double-dispatch; each handler resolves the local agent internally and that resolution
     // matches the stream the directory routed the frame to.
+    // CELLO-M8-TRUST-001: open + verify + store + ACK a sealed trust signal pushed from the directory
+    // pickup queue. The daemon is the ONLY party that can open the seal (k_local — SI-001); it verifies
+    // the recomputed hash against the directory's anchor before storing, and ACKs only on success so the
+    // directory deletes the ciphertext (AC-001/AC-002). open-fail / hash-mismatch / store-fail → NO ACK
+    // (the directory keeps the pickup for a later retry; the signal is re-mintable).
+    async function handleTrustSignalPickup(frame, keyProvider, mgr, agentName) {
+        const id = typeof frame["id"] === "string" ? frame["id"] : null;
+        const signalKind = typeof frame["signal_kind"] === "string" ? frame["signal_kind"] : null;
+        const signalHash = typeof frame["signal_hash"] === "string" ? frame["signal_hash"] : null;
+        const ciphertext = frame["ciphertext"];
+        if (!id || !signalKind || !signalHash || !(ciphertext instanceof Uint8Array)) {
+            // Neither stores nor ACKs → the directory retains the row and re-delivers. Log it: a PERMANENTLY
+            // malformed frame would otherwise be re-delivered forever with zero daemon-side signal (fallback-finder).
+            logger.warn("daemon.trust_signal.malformed", {
+                agentName,
+                hasId: !!id,
+                hasSignalKind: !!signalKind,
+                hasSignalHash: !!signalHash,
+                ciphertextOk: ciphertext instanceof Uint8Array,
+            });
+            return;
+        }
+        if (!keyProvider.openContentSeal) {
+            // A session-node stub key cannot open content seals. No ACK → the directory re-delivers; log so a
+            // pickup persistently routed to a stub-key agent is visible rather than a silent forever-retry.
+            logger.warn("daemon.trust_signal.no_content_key", { agentName, signalKind, correlationId: id });
+            return;
+        }
+        // The pickup id correlates the directory's deliver/ack with the daemon's receive (TRUST-001 obs).
+        const correlationId = id;
+        let recovered;
+        try {
+            recovered = await keyProvider.openContentSeal(ciphertext);
+        }
+        catch {
+            recovered = null;
+        }
+        if (!recovered) {
+            logger.warn("daemon.trust_signal.open_failed", { agentName, signalKind, correlationId });
+            return;
+        }
+        const recomputed = Buffer.from(cryptoHash(recovered)).toString("hex");
+        if (recomputed !== signalHash) {
+            logger.error("daemon.trust_signal.hash_mismatch", { agentName, signalKind, correlationId });
+            return;
+        }
+        try {
+            const store = new DbIdentityStore(sessionNodeManager.getDb(), logger);
+            store.storeTrustSignal({ signalHash, agentId: null, signalKind, payload: recovered });
+        }
+        catch (err) {
+            logger.error("daemon.trust_signal.store_failed", {
+                agentName,
+                signalKind,
+                correlationId,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return;
+        }
+        logger.info("daemon.trust_signal.received", { agentName, signalKind, verified: true, correlationId });
+        await mgr.sendRaw({ type: "trust_signal_ack", id });
+    }
     function wirePerAgentSessionInbound(mgr) {
         mgr.registerInboundHandler((frame) => {
             if (frame["type"] !== "seal_interrupted_request")