@cluesmith/codev 3.2.4 → 3.3.0

package/dist/agent-farm/servers/mailbox-delivery.d.ts

@@ -0,0 +1,370 @@
+/**
+ * Mailbox delivery orchestration (Spec 1313, Phase 4).
+ *
+ * The single gate-checked delivery path: **persist → serialize → gate → deliver |
+ * hold**. Both the send request (`handleSend`, after it enqueues) and the periodic
+ * backstop drainer route every GATED delivery through {@link deliverAgentMail}, so for
+ * gate-checked delivery a message body reaches a PTY in exactly one place — and only
+ * onto a prompt the render-gate has proven empty. This is what eliminates corruption by
+ * construction for that path: a message can never fuse with a draft, because it is never
+ * delivered while one exists; and there is no force path.
+ *
+ * TWO deliberate exceptions write a body OUTSIDE this path, both explicit human
+ * gate-bypasses documented at their `tower-routes.ts` call sites: immediate `--interrupt`
+ * (Ctrl+C then the message) and `--escape` (a bare ESC). They are the operator's "I am at
+ * this terminal now" actions and take the separate per-terminal submission lock
+ * (`session-submit.ts`), not the per-agent serializer here — every autonomous/scheduled/
+ * held send, by contrast, delivers through this gate.
+ *
+ * This module replaces the in-memory `SendBuffer` (retired in this phase): held
+ * messages now live in the durable `mailbox` table, so nothing is lost to a Tower
+ * crash/restart, and shutdown no longer force-flushes onto the line.
+ *
+ * Everything the delivery logic touches at the edges — resolving the live session
+ * for an agent, resolving its classifier profile (incl. the wrapped-launch
+ * fallback), running the gate, writing, broadcasting — is injected via
+ * {@link DeliveryPorts}, so the orchestration is unit-testable without a live Tower.
+ */
+import type Database from 'better-sqlite3';
+import type { DbMailbox, MailboxReason } from '../db/types.js';
+import type { GateProfile, GateVerdict } from './render-gate.js';
+/**
+ * The structural view of a live PTY session the delivery path needs. `PtySession`
+ * satisfies this (ringBuffer + info getter + the Spec 1313 identity getters +
+ * write); tests pass a fake. Kept minimal and structural so the module never
+ * imports the terminal layer.
+ */
+export interface DeliverySession {
+    /**
+     * The session's MONOTONE cumulative output-byte counter (Spec 1313 render-gate round 2) —
+     * the gate's change token. It advances on ANY new output and NEVER decreases, so two samples
+     * that match prove the classified screen is byte-for-byte unchanged. This replaces the old
+     * `currentSeq:partialBytes` pair, which was non-monotone once #1205 capped the ring's partial:
+     * a `trimPartial` makes `partialBytes` FALL, so two distinct screens could produce the same
+     * token and alias a stale memoized verdict. The delivery path samples it around the async
+     * classify to re-validate the screen hasn't moved (a keystroke landing mid-classify) before
+     * writing onto it, and the drainer memoizes the gate verdict on it so a STATIC screen is
+     * classified once, not re-checked every backstop tick (see {@link ringToken} and
+     * {@link MailboxDrainer}). `PtySession` exposes it (sourced from `RingBuffer.bytesWritten`).
+     */
+    readonly bytesWritten: number;
+    readonly info: {
+        cols: number;
+        rows: number;
+    };
+    readonly command: string;
+    readonly launchArgs: string[];
+    readonly cwd: string;
+    /**
+     * Whether input can reach the process right now (Spec 1313 iter-1 review). A
+     * shellper-backed session whose socket died still reports status 'running' until
+     * teardown, and writes to it are silently dropped (#1198) — `PtySession.writable`
+     * checks the live connection, not just status. The delivery path re-checks this at
+     * the write instant so a torn-down PTY holds the row (spec: "an errored PTY write
+     * leaves the row held") instead of being marked delivered off the paced-write timer.
+     */
+    readonly writable: boolean;
+    write(data: string): boolean;
+}
+/** Broadcast frame for a delivered message (the dashboard/inbox message event). */
+export interface DeliveredBroadcast {
+    type: 'message';
+    from: {
+        project?: string;
+        agent?: string;
+    };
+    to: {
+        project: string;
+        agent: string;
+    };
+    content: string;
+    metadata: {
+        source: 'mailbox';
+    };
+    timestamp: number;
+}
+/** Injected edges — everything the orchestration calls into the live system through. */
+export interface DeliveryPorts {
+    /** The currently-live session for an agent, or null when no PTY is live (→ held `no-live-pty`). */
+    getSessionForAgent(workspacePath: string, toAgent: string): DeliverySession | null;
+    /** The classifier profile for a session (incl. wrapped-launch resolution), or null (→ held `no-profile`). */
+    resolveProfile(session: DeliverySession): GateProfile | null;
+    /**
+     * The render-gate: classify the session's CURRENT screen against a profile (Spec 1313
+     * render-gate round 2). The live binding reads the session's persistent {@link SessionScreen}
+     * mirror and runs the classifier on its bounded viewport — no whole-ring re-render, so the
+     * capped ring can no longer hand the gate a torn frame. A session with no mirror yet (no
+     * output) classifies not-clean (`no-composer-marker`), exactly as an empty replay always did.
+     */
+    classify(session: DeliverySession, profile: GateProfile): Promise<GateVerdict>;
+    /**
+     * Write a formatted message (text + Enter, unless `noEnter`) to the session and
+     * report whether every byte reached the terminal. Resolves `true` when the paced
+     * write — including the trailing Enter — has fully completed; `false` when any
+     * write was dropped (#1198: a shellper socket that died mid-pace). The delivery
+     * `await`s it for two reasons: (1) completion chaining — the per-agent serializer
+     * holds the line until the submit is entirely on the wire, so the next delivery
+     * never starts mid-write; (2) the boolean gates markDelivered — a dropped write
+     * holds the row (`no-live-pty`) instead of falsely reporting delivery (Spec 1313
+     * integration review — the silent-loss finding).
+     */
+    writeMessage(session: DeliverySession, formattedMessage: string, noEnter: boolean): boolean | Promise<boolean>;
+    /** Emit the delivered-message broadcast frame. */
+    broadcast(frame: DeliveredBroadcast): void;
+    /**
+     * Fire the SSE `overview-changed` event so the held-count indicator refetches (Spec
+     * 1313, Phase 7). Called whenever the held SET changes via this module — a delivery
+     * here removes a held row; the other transitions (hold/supersede/dismiss) fire it
+     * from their own call sites. Cheap and idempotent (it only triggers a refetch), so an
+     * extra fire is harmless. A no-op in unit fakes.
+     */
+    onHeldStateChange(): void;
+    /**
+     * Fire the SSE `mailbox-escalation` event when a held row crosses the escalation age
+     * (Spec 1313, Phase 7). VISIBILITY ONLY — the caller never delivers as a result. A
+     * no-op in unit fakes.
+     */
+    onEscalation(info: EscalationInfo): void;
+    /**
+     * Raise the liveness-telemetry diagnostic when an agent's mail has been held
+     * `no-profile` for a sustained streak (Spec 1313, Phase 7 — spec line 91). The pure
+     * module just reports the streak crossing; the live binding applies the spec's "with
+     * recent output" condition (only a session actively producing output is a genuinely
+     * broken/unknown classifier worth alarming) and does the loud log + broadcast. A
+     * no-op in unit fakes.
+     */
+    onLiveness(info: LivenessInfo): void;
+    /**
+     * Raise a starvation notice to a starving NON-architect agent's OWNER (Spec 1313 round 3,
+     * change 3). Fired once per episode when the agent's oldest eligible held row has been stuck
+     * past the owner-notice threshold. The live binding resolves the recipient architect
+     * (spawning → workspace `main` → first-registered, mirroring `afx send architect`), skips
+     * agents that are themselves architects (a notice would land in the same starved mailbox —
+     * `afx status` covers that), and enqueues ONE coalesced (supersede-keyed), gate-delivered
+     * mailbox row — never a force path. OPTIONAL: unit fakes that don't exercise the notice omit
+     * it, so the drainer calls it via `?.`.
+     *
+     * RETURNS `true` iff a notice was actually enqueued; `false` on a no-op (recipient is itself
+     * an architect, or no architect is registered yet). The drainer only records the agent as
+     * notified on `true` — a no-op must NOT arm the once-per-episode guard, or the alarm would be
+     * suppressed for the whole episode even after an architect later registers (it retries each
+     * tick until one enqueues).
+     */
+    escalateHeldToOwner?(info: HeldOwnerNoticeInfo): boolean;
+    /**
+     * Clear (dismiss) any pending owner notice for an agent whose eligible held set has drained
+     * (Spec 1313 round 3) — the starvation is over, so the alarm is moot. A no-op on an
+     * already-delivered notice. OPTIONAL, like {@link escalateHeldToOwner}.
+     */
+    clearHeldOwnerNotice?(workspacePath: string, toAgent: string): void;
+    log(message: string): void;
+    now(): number;
+}
+/**
+ * Metadata for a starving agent whose owner should be alarmed (Spec 1313 round 3, change 3).
+ * Carries NO message body (metadata only, per the redaction rule) — the live binding formats a
+ * human notice naming the agent, its held count, how long it has been stuck, and the remedy.
+ */
+export interface HeldOwnerNoticeInfo {
+    /** The starving agent's workspace (the notice is enqueued within it). */
+    workspacePath: string;
+    /** The starving NON-architect agent (a builder id). */
+    toAgent: string;
+    /** Its current why-held reason (busy/no-profile/no-live-pty), if the gate set one. */
+    reason: MailboxReason | null;
+    /** How long the oldest eligible held row has been stuck, in ms. */
+    ageMs: number;
+    /** How many eligible held rows are backed up for the agent. */
+    heldCount: number;
+}
+/**
+ * A sustained `no-profile` hold streak for an agent — carried to the liveness-telemetry
+ * binding (Spec 1313, Phase 7). Metadata only (no body): the diagnostic names the agent
+ * and how many consecutive checks failed to classify, so a broken/unknown classifier is
+ * discoverable rather than silent.
+ */
+export interface LivenessInfo {
+    workspacePath: string;
+    toAgent: string;
+    /** Consecutive not-clean (`no-profile`) checks at the moment the streak crossed the threshold. */
+    streak: number;
+}
+/**
+ * Metadata for a held row that has crossed the escalation age. Carries NO message body
+ * (ids + metadata only, per the spec's redaction rule) — this rides the SSE bus to the
+ * dashboard/VSCode indicator, which is count/attention only.
+ */
+export interface EscalationInfo {
+    workspacePath: string;
+    toAgent: string;
+    mailboxId: string;
+    /** How long the row had been held when it escalated, in ms. */
+    ageMs: number;
+    reason: MailboxReason | null;
+}
+/** Outcome of one delivery pass over an agent's held mail. */
+export interface DeliveryOutcome {
+    /** Row ids delivered this pass — 0 or 1 (one message per clean gate; its Enter makes the line busy). */
+    delivered: string[];
+    /** When nothing was delivered, why the agent's mail stays held; null if delivered or the mailbox was empty. */
+    reason: MailboxReason | null;
+    /**
+     * The gate's internal detail when a `busy` hold came from the render-gate (Spec 1313
+     * render-gate hardening) — telemetry only. Distinguishes a legitimately-occupied line
+     * (`user-text`, a human present) from a classifier that CANNOT verify the composer
+     * (`no-region-end`/`no-composer-marker` = a drifted profile or an unrenderable frame),
+     * which {@link MailboxDrainer.recordStreak} escalates to liveness telemetry. Absent
+     * for non-gate holds (`no-live-pty`/`no-profile`) and deliveries.
+     */
+    detail?: GateVerdict['detail'];
+}
+/**
+ * Composite key identifying an agent within a workspace, used to dedupe the
+ * backstop's per-agent work and to key the liveness-telemetry streak map (which
+ * Phase 7 consumes). Joined on a NUL — a byte that can appear in neither a
+ * filesystem path nor an agent id — so the key is collision-proof (a space
+ * separator would be ambiguous for paths/ids that contain spaces). Kept explicit
+ * (visible `\0`) and shared so callers never hand-roll the separator.
+ */
+export declare function agentKey(workspacePath: string, toAgent: string): string;
+/**
+ * A gate verdict cached against BOTH the live session instance and the {@link ringToken}
+ * that produced it (Spec 1313 render-gate verdict memo). Reuse requires the SAME session
+ * object AND an unchanged token, so a cached verdict can never be served for a screen that
+ * has moved. The `session` guard closes the RESPAWN route: a replacement `PtySession` for the
+ * same `agentKey` starts a fresh `bytesWritten` at 0 and could transiently reproduce a low
+ * token value — but it is a DIFFERENT object, so `cached.session === session` misses. (The old
+ * `RingBuffer.clear()`-during-teardown aliasing route — which left `currentSeq` untouched while
+ * wiping content — is now closed by the token itself: `bytesWritten` is monotone and `clear()`
+ * does NOT reset it, so a cleared ring's token can only advance, never collide with a prior
+ * value; the `!session.writable` filter still keeps a torn-down session out of the memo anyway.)
+ * CMAP round 1/2: Gemini/Codex/Claude. Holding the session pins it for at most one tick (the
+ * drainer prunes to the held-agent set each tick).
+ * Keyed/bounded by {@link MailboxDrainer}; see {@link deliverAgentMail}.
+ */
+interface CachedVerdict {
+    session: DeliverySession;
+    token: string;
+    verdict: GateVerdict;
+}
+/** Reconstruct the delivered-message broadcast frame from a persisted row. */
+export declare function broadcastForRow(row: DbMailbox, now: number): DeliveredBroadcast;
+/**
+ * Run one delivery pass for a single agent against the live gate.
+ *
+ * Delivers the **oldest** held message when — and only when — the composer is a
+ * render-verified empty prompt; the rest wait for the next clean gate (the just-
+ * delivered message's Enter submits and makes the line busy, so at most one lands
+ * per pass — never a blob). When it cannot deliver, it refreshes every held row's
+ * `reason` to the current gate verdict so `afx inbox` and the send response stay
+ * accurate. Idempotent and race-safe: `markDelivered` only transitions a still-held
+ * row, so a backstop tick racing a request-path delivery can never double-send.
+ */
+export declare function deliverAgentMail(ports: DeliveryPorts, db: Database.Database, workspacePath: string, toAgent: string, memo?: Map<string, CachedVerdict>): Promise<DeliveryOutcome>;
+/**
+ * {@link deliverAgentMail}, serialized per agent through the shared
+ * {@link KeyedSerializer}. This is the entry point every live caller must use;
+ * the bare `deliverAgentMail` is exported only so unit tests can drive a single
+ * pass deterministically.
+ */
+export declare function deliverAgentMailSerialized(ports: DeliveryPorts, db: Database.Database, workspacePath: string, toAgent: string, memo?: Map<string, CachedVerdict>): Promise<DeliveryOutcome>;
+/**
+ * The poll backstop that replaces `SendBuffer`'s flush timer. On each tick it walks
+ * every agent with held mail and runs {@link deliverAgentMail}, so a message held
+ * on a busy line delivers on the first tick after the line clears (Phase 5 adds the
+ * fast submit/quiescence triggers on top). It also prunes terminal rows on boot and
+ * per tick, and tracks a per-agent consecutive-not-clean streak for liveness
+ * telemetry (Phase 7 surfaces it as a loud log/broadcast). Shutdown just stops the
+ * timer — nothing is force-flushed, because every held row is already persisted.
+ */
+export declare class MailboxDrainer {
+    private timer;
+    private ticking;
+    private ports;
+    private db;
+    private readonly intervalMs;
+    private readonly retentionDays;
+    private readonly escalationMs;
+    private readonly ownerNoticeMs;
+    private readonly notCleanStreak;
+    private readonly notifiedAgents;
+    private readonly scheduledDrains;
+    private readonly verdictMemo;
+    private generation;
+    constructor(opts?: {
+        intervalMs?: number;
+        pruneRetentionDays?: number;
+        escalationMs?: number;
+        ownerNoticeMs?: number;
+    });
+    start(ports: DeliveryPorts, db: Database.Database): void;
+    stop(): void;
+    /** Per-agent consecutive not-clean count (liveness telemetry; Phase 7 reads this). */
+    get streaks(): ReadonlyMap<string, number>;
+    /**
+     * Agent keys that currently hold a cached gate verdict (render-gate memo).
+     * Observability/test only: {@link tick} prunes this to the current held-agent set, so
+     * it never grows past the number of agents holding mail.
+     */
+    get memoizedAgents(): ReadonlyArray<string>;
+    /** One backstop pass. Guarded against re-entry so a slow gate can't overlap ticks. */
+    tick(): Promise<void>;
+    /**
+     * Escalation pass (Spec 1313, Phase 7). Flags every held row that has crossed the
+     * escalation age (`escalationMs`, default 60s) as `escalated` and emits the
+     * `onEscalation` visibility broadcast + a loud log. **VISIBILITY ONLY — it never
+     * delivers.** `findEscalatable` returns only not-yet-escalated held rows and
+     * `markEscalated` is idempotent, so each row escalates (and broadcasts) exactly
+     * once; the row still delivers only on a later clean gate pass, and the attention
+     * state clears when it resolves (the row leaves the held set).
+     */
+    private escalateOverdue;
+    /** Agents with a pending owner starvation notice this lifetime (test/observability). */
+    get notifiedOwnerAgents(): ReadonlyArray<string>;
+    /**
+     * Owner starvation-notice pass (Spec 1313 round 3, change 3). When an agent's OLDEST eligible
+     * held row has been deliverable-but-stuck past the owner-notice threshold, alarm the agent's
+     * OWNER exactly once per episode via {@link DeliveryPorts.escalateHeldToOwner} — the live
+     * binding resolves the recipient architect (spawning → workspace `main` → first-registered),
+     * skips agents that are themselves architects, and enqueues ONE coalesced, gate-delivered
+     * notice. When a previously-notified agent's eligible held set drains, the pending notice is
+     * cleared via {@link DeliveryPorts.clearHeldOwnerNotice}. VISIBILITY ONLY — never delivers.
+     *
+     * The two spec guards hold by construction: {@link findStarvingAgents} excludes PRE-DUE
+     * delayed rows (a scheduled send is not stuck) and NOTICE rows themselves (a notice can never
+     * trigger a notice). The once-per-episode guard is {@link notifiedAgents}, armed ONLY after a
+     * notice is actually enqueued (an `escalateHeldToOwner` that no-ops — no architect yet, or the
+     * recipient is itself an architect — leaves the guard unset and retries next tick);
+     * `escalateHeldToOwner` additionally coalesces via a supersede key, so even a post-restart
+     * re-notify stays a single pending row.
+     */
+    private noticeOverdue;
+    /**
+     * Update the per-agent liveness streak from a delivery outcome (Phase 7 surfaces
+     * it): a delivered or empty pass clears the streak; a held pass grows it. Shared by
+     * the backstop {@link tick} and the fast {@link scheduleDrain} trigger so both feed
+     * the same telemetry.
+     */
+    private recordStreak;
+    /**
+     * Fast, event-driven delivery trigger (Spec 1313, Phase 5). A submit (Enter) or
+     * output-quiescence signal for a session schedules a single coalesced delivery pass
+     * for that agent, so a held message delivers within a microtask of the line
+     * clearing instead of waiting up to one backstop interval.
+     *
+     * Triggers are schedulers, never authority (spec Constraint): this runs the SAME
+     * gated {@link deliverAgentMailSerialized} the backstop does, so a spurious trigger
+     * on a still-busy screen simply re-holds, and a missed trigger only defers delivery
+     * to the next backstop tick — a trigger can never corrupt anything.
+     *
+     * Coalescing: while a pass is already queued for an agent, further triggers return
+     * the same in-flight promise (the gate runs once, not once per trigger). The slot is
+     * released just before the pass runs, so a trigger arriving *during* a pass queues
+     * exactly one follow-up; the per-agent {@link KeyedSerializer} keeps passes from
+     * overlapping. No-op (resolved) until the drainer is started, and never rejects — a
+     * gate/write error is logged and left for the backstop, mirroring the tick.
+     */
+    scheduleDrain(workspacePath: string, toAgent: string): Promise<void>;
+}
+export {};
+//# sourceMappingURL=mailbox-delivery.d.ts.map

package/dist/agent-farm/servers/mailbox-delivery.d.ts.map

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