@cello-protocol/daemon 0.0.225 → 0.0.227

package/dist/inbound-refusals.d.ts

@@ -1,283 +0,0 @@
-/**
- * CELLO Daemon — HOLDING WHAT WAS REFUSED, AND WHERE A MESSAGE SITS IN THE ORDER
- *
- * Split out of `session-node-manager.ts` by 036-GODFILE, Parts 3 and 4. Everything that happens to
- * an inbound message this daemon will NOT deliver: quarantining the bytes so the operator has an
- * artifact to show, triaging one that belongs to no session, saying why authorship could not be
- * proven, remembering a terminal refusal, and recording the relay position a frame claims.
- *
- * Moved verbatim, comments included. Much of the prose here records a defect that came back once
- * already, and several of the bounds exist because the map they guard is fed by a remote party.
- *
- * ⚠️ THIS CLASS OWNS THE FIVE PER-SESSION CONTAINERS IT MAINTAINS, which is what made it a seam.
- * THREE of them are capped per session because a remote peer feeds them (`#terminallyRefused`,
- * `#unreadableAlgSeen`, `#refusedOnDirectPath`); the other two — `#terminalRefusalsLoaded`, a SET
- * rather than a map, and `#terminalRefusalsReadFailedAt` — carry no cap and grow one entry per
- * session, so `evictSession` is the only thing that releases them. Said precisely because "each is
- * bounded" reads as a safety property and only three of the five have it.
- *
- * They used to be cleared field-by-field from the manager's cache eviction; that is now one
- * `evictSession` call, which is the point — a caller that had to know five field names in order to
- * forget a session knew too much.
- */
-import type { DaemonDatabase } from "./sqlcipher-db.js";
-import type { Logger } from "./types.js";
-import type { RefusalKind } from "./refusal-reasons.js";
-import type { OrphanEvidence } from "./orphan-triage.js";
-import { type AuthorshipVerdict, type AckHashReason, AUTHORSHIP_SELF_CHAIN_MISMATCH } from "./session-node-types.js";
-/**
- * Everything this module needs from the manager, stated explicitly rather than handed `this`.
- *
- * `db()` is a FUNCTION, not a value: the manager opens its database after construction, so a
- * snapshot taken at wiring time would be null forever.
- */
-export interface RefusalContext {
-    readonly logger: Logger;
-    /**
-     * ⚠️ A FUNCTION, because the manager opens its database AFTER construction — a value snapshotted
-     * at wiring time would be null for the life of the process. The class re-exposes it as a private
-     * getter (`#db`) so the moved code keeps saying `this.#db`, exactly as it did in the manager.
-     */
-    db(): DaemonDatabase | null;
-    sessionKey(agentName: string, sessionId: string): string;
-    requireAgentId(agentName: string): string;
-    /** Cancels a pending leaf fetch. The timers stay the manager's — this side only says "stop". */
-    cancelLeafFetch(sessionKey: string, contentHashHex: string): void;
-    /**
-     * The operator-facing refusal surface. Every refusal in this module reaches a READER through one
-     * of these — a refusal whose only consumer is the log is not a control (M15 Invariant 2).
-     */
-    noteContentRefusal(agentName: string, sessionId: string, reason: string, detail: {
-        kind: RefusalKind;
-        impact: string;
-        guidance: string;
-    }): void;
-    recordTranscriptMessage(agentName: string, sessionId: string, sequence: number, direction: "sent" | "received" | "quarantined", plaintext: Uint8Array, correlationId?: string, authorship?: {
-        senderPubkey: Uint8Array;
-        senderSig: Uint8Array;
-    }, quarantineReason?: string, senderPubkeyHexOverride?: string | null): boolean;
-    recordWitnessedSequence(agentName: string, sessionId: string, contentHashHex: string, sequenceNumber: number): void;
-    getTier(agentName: string, pubkey: string): number;
-    resolveTierBound(agentName: string, tier: number, field: "max_sessions" | "max_bytes"): number;
-    /** Is there a relay mailbox this refusal could still arrive by? It changes what the operator is told. */
-    mailboxRouteAvailable(agentName: string): boolean;
-    receivedBytesTotal(agentName: string, sessionId: string): number;
-    /**
-     * Part 1's verifier. Ordering asks the same question of the RELAY's copy of the signature that the
-     * content frame asks of the one carried beside the bytes — both must hold, and if they disagree
-     * one of them was altered in flight.
-     */
-    verifyAuthorshipClaim(agentName: string, sessionId: string, structure1Cbor: Uint8Array, senderSignature: Uint8Array, contentHash: Uint8Array): AuthorshipVerdict;
-}
-export declare class InboundRefusals {
-    #private;
-    constructor(ctx: RefusalContext);
-    /**
-     * DOD-M15-REFUSEDEVIDENCE-1 — RETAIN a message that was refused. Retention is universal; DELIVERY
-     * is what is withheld.
-     *
-     * Every refusal path that can store calls this. It writes the plaintext, the sender's key, the
-     * sender's signature and the refusal reason into the transcript, flagged `'quarantined'` so it is
-     * excluded by construction from delivery and from unread counts.
-     *
-     * ⚠️ STORING HOSTILE CONTENT IS SAFE; INTERPOLATING IT IS NOT. The blob is a bound parameter and
-     * the database never parses it — SQL injection is not the risk here and must not be defended
-     * against. The risk is on the way OUT, so nothing below puts `content` into a log line, an error
-     * message or a path. The log carries the length and the hash.
-     *
-     * Returns the sequence it was stored at, or `null` when it was not stored — which happens only for
-     * a reason the caller is expected to log.
-     */
-    quarantineRefusedContent(agentName: string, sessionId: string, reason: string, content: Uint8Array, contentHashHex: string, opts: {
-        senderPubkeyHex?: string | null;
-        authorship?: {
-            senderPubkey: Uint8Array;
-            senderSig: Uint8Array;
-        };
-        canonicalSeq?: number;
-        correlationId?: string;
-    }): number | null;
-    /** DOD-M15-REFUSEDEVIDENCE-1: the retention itself. Reached only through the funnel above. */
-    retainRefusedContent(agentName: string, sessionId: string, reason: string, content: Uint8Array, contentHashHex: string, opts: {
-        /** The sender's key when this side resolved one. `null` is itself evidence. */
-        senderPubkeyHex?: string | null;
-        /** The VERIFIED authorship proof, when the frame carried one that checked out. */
-        authorship?: {
-            senderPubkey: Uint8Array;
-            senderSig: Uint8Array;
-        };
-        /** The relay-assigned position, for a refusal that DOES occupy one (a screener block). */
-        canonicalSeq?: number;
-        correlationId?: string;
-    }): number | null;
-    /**
-     * DOD-M15-REFUSALTERMINAL-1 — the funnel. A refusal stops the work ONLY if its reason is in
-     * `TERMINAL_REFUSAL_REASONS`; every other reason keeps retrying, which is what makes a transient
-     * screener block or a version skew recoverable.
-     *
-     * One place decides, so "is this reason terminal?" is answerable from the set rather than from
-     * thirteen call sites.
-     */
-    considerTerminalRefusal(agentName: string, sessionId: string, contentHashHex: string, reason: string): void;
-    /**
-     * DOD-M15-REFUSALTERMINAL-1: this content can NEVER be accepted on this session — cancel the
-     * pending fetch and make sure no future one is scheduled, across restarts.
-     *
-     * The durable write comes FIRST and the in-memory cache second, so a process that dies between
-     * them wakes up with the stop still in force. A failed write is announced at ERROR and the
-     * in-memory mark is still taken: the loop stops for the life of THIS process, and the log says
-     * plainly that it will resume after a restart. That is a degraded stop, not a silent one.
-     */
-    markContentTerminallyRefused(agentName: string, sessionId: string, contentHashHex: string, reason: string): void;
-    /**
-     * DOD-M15-REFUSALTERMINAL-1: has this content already been refused terminally?
-     *
-     * Reads the durable rows for a session ONCE and caches them, so the hot path — a witnessed leaf
-     * on a healthy session — costs one `Set` lookup rather than a query per message. A read failure
-     * returns `false`: the cost is the loop continuing, which is the pre-fix behaviour, and it is
-     * announced rather than swallowed. Answering `true` on a failed read would be the dangerous
-     * direction, because it silently stops fetching content that was never refused.
-     */
-    isTerminallyRefused(agentName: string, sessionId: string, contentHashHex: string): boolean;
-    /**
-     * 024-ORPHANTRIAGE — the three signals, read from evidence this side owns.
-     *
-     * ⚠️ **THE SEQUENCE NUMBER ON THE FRAME IS NOT ONE OF THEM.** "Was there an ongoing conversation
-     * up to this point" is tempting to answer from the position the sender wrote, and that answer is
-     * worthless: the sender picks the number, so anyone wanting the reach-out branch writes a large
-     * one. It is answered from OUR transcript rows instead — a partial local record of that
-     * conversation is something an attacker cannot put there from the wire.
-     *
-     * ⚠️ **"KNOWN" IS A TIER, NOT A ROW — review F1/F2, and reading it as a row inverted the unit.**
-     * `contacts` rows are written from the WIRE with no operator action: `inbound-sessions.ts` calls
-     * `addContact(..., "signal_presentation")` at `TIER.UNKNOWN` for any inbound offer inside the
-     * acceptance bound, because the trust-signal foreign key needs a row to point at. And BLOCKING a
-     * contact is an UPDATE to `TIER.BLOCKED`, so the row survives that too. A `SELECT … WHERE pubkey`
-     * therefore answers "yes, known" for a stranger who merely dialled, AND for a key the operator
-     * deliberately blocked — handing both the reach-out branch, which is the exact population this
-     * unit exists to refuse. `DOD-TIER-4` had already settled this and retired `isContact` for it:
-     * *"An UNKNOWN-tier contact (a mere row) is NOT known."* The tier is read from the row already
-     * being fetched, so the case-insensitivity below survives (`getTier` compares case-sensitively).
-     *
-     * ⚠️ **HEX CASE IS NOT A DIFFERENCE IN IDENTITY.** This unit originally worked around that with its
-     * own `lower(pubkey)` lookup, because `contacts.pubkey` was stored verbatim from the IPC parameter
-     * and an exact match would report a contact the operator can SEE in `cello_contacts` as an unknown
-     * stranger. The workaround is gone: `contact-pubkey-case.ts` now normalizes every contacts
-     * accessor and folds the rows already on disk, so there is one spelling and one rule.
-     */
-    orphanEvidence(agentName: string, sessionId: string, verifiedSignerUnmatched: Uint8Array | undefined): OrphanEvidence;
-    /**
-     * `DOD-M15-AUTHORSHIP-ABSENT-1` — the refusal an inbound frame gets when its authorship cannot be
-     * established. NOT a freeze: see `AuthorshipVerdict` for why those are different facts.
-     *
-     * Both surfaces, always. The ERROR is the durable forensic record an investigation reads days
-     * later; the notice is the CONTROL — the thing that actually reaches the operator, who otherwise
-     * watches a conversation go quiet and concludes the other person stopped replying.
-     */
-    refuseUnprovenAuthorship(agentName: string, sessionId: string, reason: "authorship_proof_absent" | "authorship_proof_unusable" | "authorship_wrong_conversation" | typeof AUTHORSHIP_SELF_CHAIN_MISMATCH | AckHashReason, contentHash: Uint8Array, detail: Record<string, unknown>, correlationId?: string): void;
-    recordFrameOrdering(agentName: string, sessionId: string, structure1Cbor: Uint8Array, structure2Cbor: Uint8Array, contentHash: Uint8Array, correlationId?: string, source?: string): {
-        seq: number | null;
-        fatal?: {
-            reason: string;
-        };
-    };
-    /**
-     * DAEMON-004: cross-check received content against its hash, append the
-     * verified leaf to the daemon-owned tree, and buffer it for cello_receive.
-     * A hash MISMATCH is genuine tamper — rejected without append or buffer.
-     *
-     * SCOPE / finding #5 — what this cross-check proves BY ITSELF, and what proves the rest:
-     * `contentHash` here is carried in the SAME content_frame as `content`, so this comparison on its
-     * own catches wire corruption of a single frame and nothing more. It is not what establishes that
-     * the sender committed to these bytes. That proof arrives separately and is checked BEFORE any
-     * caller reaches this method.
-     *
-     * ⚠️ **THE RULE THIS PARAGRAPH EXISTS TO ENFORCE: a comment that says a protection is missing
-     * must be re-read whenever the protection lands, because in a PUBLIC repository it keeps handing
-     * a reader a hole that is already closed.** This one said: *"Full tamper-evidence (EARS behavior
-     * #2) requires cross-checking against the K_local-signed content_hash leaf the sender submits to
-     * the RELAY on a separate channel; that relay hash-submit path is MSG-001's scope and **does not
-     * exist yet**. Until MSG-001 lands, a malicious sender that sends matching (content, hash) in one
-     * frame is not detected here — only the relay-relayed signed leaf closes that gap."* True when
-     * written; the quote stays because its last clause predicts the wrong closure, as below.
-     *
-     * What closes it today — and note it is NOT only the route the old sentence predicted:
-     *   - The relay hash-submit path EXISTS (`relay-node.ts` `#processHashSubmit`), so the separate
-     *     channel the paragraph was waiting for is built.
-     *   - `DOD-M15-AUTHORSHIP-ABSENT-1` then made the relay unnecessary for this question: the
-     *     sender's signature over their own Structure 1 travels on the content frame beside the bytes
-     *     it signs. `#verifyAuthorshipClaim` verifies it against the pubkey inside those signed bytes
-     *     and matches the signer to this session's counterparty; a frame carrying nothing checkable is
-     *     refused by name (`authorship_proof_absent`), so omitting the proof is not the softer option
-     *     it once was. That verdict reaches this method as `verifiedAuthorship`.
-     *   - The PARK-RECOVERY caller deliberately passes no `verifiedAuthorship`, and is not an
-     *     exception to the above: recovered mail is authenticated by its park ENVELOPE's own
-     *     signature (`authenticateParkedEntry`) before any of it is ingested — note the order is
-     *     unseal THEN authenticate, so the envelope signature gates the append, not the decrypt.
-     *     Two routes, both cryptographic, and the transcript row records which one attested the
-     *     message rather than implying a proof it does not have.
-     *
-     * @returns the appended leaf index (as sequenceNumber) on success.
-     */
-    /**
-     * Mark this session's content unverifiable — review F1, and every path that fails the cross-check
-     * must come through here.
-     *
-     * It gates `getSealUpgradeReadiness().tampered` and the auto-acknowledge check, i.e. whether this
-     * agent's key signs anything covering content it could not check. Three refusal paths reach it and
-     * they carry different labels, because what the operator is told must differ; **what the gate does
-     * must not.**
-     *
-     * TAMPERED NEVER DOWNGRADES. A session that has already seen a hash mismatch stays `tampered` even
-     * if a later frame merely names an unreadable algorithm — otherwise a sender that had been caught
-     * could clear its own alarm by sending one more frame with a junk algorithm name, and the seal
-     * would auto-complete.
-     */
-    /**
-     * Remember that THIS frame was refused for naming an unreadable algorithm, so the park path can
-     * say so if the same message comes back the other way (review F2/F-D).
-     *
-     * BOUNDED, and it has to be: a peer that keeps sending unreadable frames would otherwise grow this
-     * without limit, and it is fed entirely by a remote party. The cap is per session and it drops the
-     * OLDEST entry — losing one only costs a missing reconciliation line, whereas an unbounded map fed
-     * by a counterparty is the leak class this codebase has already caught twice.
-     */
-    noteUnreadableAlgFrame(agentName: string, sessionId: string, contentHash: Uint8Array, declaredAlg: string): void;
-    /**
-     * Remember that THIS frame was refused for carrying no usable proof of who wrote it, so the park
-     * path can say so when the same content arrives through the relay mailbox — review H1.
-     *
-     * Bounded for the same reason and by the same cap as `#noteUnreadableAlgFrame`: a peer sending
-     * unprovable frames feeds this map, so it drops the oldest rather than growing.
-     */
-    noteRefusedOnDirectPath(agentName: string, sessionId: string, contentHash: Uint8Array): void;
-    /**
-     * What algorithm did we refuse this content for naming, on the DIRECT path?
-     *
-     * Read by park recovery so it can tell the operator the message arrived by the other route after
-     * all. Returns `undefined` when there was no such refusal.
-     */
-    priorUnreadableAlg(agentName: string, sessionId: string, contentHashHex: string): string | undefined;
-    /**
-     * Forget one direct-path algorithm refusal, because the same content arrived by the mailbox.
-     *
-     * ⚠️ CLEARED ONLY ON A REAL RECONCILIATION. Clearing on the LOOKUP forgets the refusal even when
-     * the recovery then fails, and the next genuine reconciliation says nothing — that was the defect,
-     * and separating the read from the clear is what fixed it. Both halves stay separate here.
-     */
-    clearUnreadableAlg(agentName: string, sessionId: string, contentHashHex: string): void;
-    /** Was this content refused on the direct path for carrying no usable proof of who wrote it? */
-    wasRefusedOnDirectPath(agentName: string, sessionId: string, contentHashHex: string): boolean;
-    /** Forget one direct-path authorship refusal — same reconciliation rule as the algorithm memo. */
-    clearRefusedOnDirectPath(agentName: string, sessionId: string, contentHashHex: string): void;
-    /**
-     * Forget everything this module holds for one session.
-     *
-     * ⚠️ THIS EXISTS SO NO CALLER HAS TO KNOW THE FIELD NAMES. The manager's cache eviction used to
-     * clear these five maps by hand, which made adding a sixth a silent bug waiting to happen — the
-     * kind that leaves a bounded, remote-fed map growing for the life of the process. One call now,
-     * and the list of what to forget lives beside the code that fills them.
-     */
-    evictSession(agentName: string, sessionId: string): void;
-}
-//# sourceMappingURL=inbound-refusals.d.ts.map

package/dist/inbound-refusals.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"inbound-refusals.d.ts","sourceRoot":"","sources":["../src/inbound-refusals.ts"],"names":[],"mappings":"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"}