@code-yeongyu/senpi-agent-core 2026.10.27-2 → 2026.10.30-2

package/dist/transport/testing/fault-transport.js

@@ -0,0 +1,144 @@
+/**
+ * The five QX2 fault profiles as test parameters (not product settings). The plan fixes their shape; the numbers here are
+ * this suite's until M0 records final values in the gate's fault-profiles.json.
+ */
+const PROFILES = {
+    slow: { perTick: 1, tickMs: 10 },
+    lossy: { lossRate: 0.2, seed: 7 },
+    laggy: { latencyMs: 40, jitterMs: 60, seed: 11 },
+    flap: { upMs: 100, downMs: 60, cycles: 8 },
+    "drop-reattach": { everyMessages: 9, reattachMs: 30, repetitions: 6 },
+};
+export const FAULT_PROFILE_NAMES = ["slow", "lossy", "laggy", "flap", "drop-reattach"];
+const mulberry32 = (seed) => {
+    let state = seed >>> 0;
+    return () => {
+        state = (state + 0x6d2b79f5) >>> 0;
+        let t = state;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+};
+function wrapWith(send) {
+    return (side) => {
+        let current;
+        return {
+            attached: (connection) => {
+                current = connection;
+                const live = () => current === connection;
+                side.attached({
+                    send: (message) => send(connection, side, message, live),
+                    close: () => connection.close(),
+                });
+            },
+            message: (message) => side.message(message),
+            writable: () => side.writable(),
+            detached: () => {
+                current = undefined;
+                side.detached();
+            },
+        };
+    };
+}
+function slow(timers, stats) {
+    const { perTick, tickMs } = PROFILES.slow;
+    const used = new WeakMap();
+    return (inner, side, message, live) => {
+        const tick = Math.floor(timers.now() / tickMs);
+        const state = used.get(side) ?? { tick, count: 0, waiting: false };
+        if (state.tick !== tick)
+            Object.assign(state, { tick, count: 0 });
+        used.set(side, state);
+        if (state.count < perTick) {
+            state.count += 1;
+            return inner.send(message);
+        }
+        stats.refused += 1;
+        if (!state.waiting) {
+            state.waiting = true;
+            timers.setTimer(() => {
+                state.waiting = false;
+                if (live())
+                    side.writable();
+            }, (tick + 1) * tickMs - timers.now());
+        }
+        return false;
+    };
+}
+function lossy(stats) {
+    const random = mulberry32(PROFILES.lossy.seed);
+    return (inner, _side, message) => {
+        if (random() < PROFILES.lossy.lossRate) {
+            stats.lost += 1;
+            return true;
+        }
+        return inner.send(message);
+    };
+}
+function laggy(timers, stats) {
+    const { latencyMs, jitterMs, seed } = PROFILES.laggy;
+    const random = mulberry32(seed);
+    const order = new WeakMap();
+    return (inner, side, message, live) => {
+        const state = order.get(side) ?? { sent: 0, highest: 0 };
+        order.set(side, state);
+        state.sent += 1;
+        const index = state.sent;
+        timers.setTimer(() => {
+            if (!live())
+                return;
+            if (index < state.highest)
+                stats.reordered += 1;
+            state.highest = Math.max(state.highest, index);
+            inner.send(message);
+        }, latencyMs + Math.floor(random() * jitterMs));
+        return true;
+    };
+}
+function flap(timers, stats, link) {
+    const { upMs, downMs, cycles } = PROFILES.flap;
+    for (let cycle = 0; cycle < cycles; cycle++) {
+        const start = timers.now() + cycle * (upMs + downMs);
+        timers.setTimer(() => {
+            stats.drops += 1;
+            link.drop();
+        }, start + upMs - timers.now());
+        timers.setTimer(() => link.connect(), start + upMs + downMs - timers.now());
+    }
+}
+/** Builds one profile's fault for the link a case opens. */
+export function createCarrierFault(name, stats) {
+    return (timers) => {
+        let link;
+        const passThrough = (inner, _side, message) => inner.send(message);
+        let sent = 0;
+        const dropReattach = (inner, _side, message) => {
+            const { everyMessages, reattachMs, repetitions } = PROFILES["drop-reattach"];
+            sent += 1;
+            if (sent % everyMessages === 0 && stats.drops < repetitions && link !== undefined) {
+                const target = link;
+                stats.drops += 1;
+                timers.setTimer(() => target.drop(), 0);
+                timers.setTimer(() => target.connect(), reattachMs);
+            }
+            return inner.send(message);
+        };
+        const sends = {
+            slow: slow(timers, stats),
+            lossy: lossy(stats),
+            laggy: laggy(timers, stats),
+            flap: passThrough,
+            "drop-reattach": dropReattach,
+        };
+        return {
+            wrap: wrapWith(sends[name]),
+            start(started) {
+                link = started;
+                if (name === "flap")
+                    flap(timers, stats, started);
+            },
+        };
+    };
+}
+//# sourceMappingURL=fault-transport.js.map

package/dist/transport/testing/multi-cases.d.ts

@@ -0,0 +1,6 @@
+import type { CaseImplementation } from "../../conformance/runner.ts";
+import { type TransportCaseAdapters } from "./transport-harness.ts";
+type MultiCase = CaseImplementation<TransportCaseAdapters>;
+export declare const MULTI_CASES: ReadonlyMap<string, MultiCase>;
+export {};
+//# sourceMappingURL=multi-cases.d.ts.map

package/dist/transport/testing/multi-cases.js

@@ -0,0 +1,113 @@
+import { createCarrierFault } from "./fault-transport.js";
+import { allDelivered, expectExactDelivery, openLink, range, } from "./transport-harness.js";
+const manyLanes = async (adapters) => {
+    const link = openLink(adapters);
+    const lanes = range(1, 8).map((n) => `scope-${n}`);
+    const counts = Object.fromEntries(lanes.map((lane) => [lane, 25]));
+    const sends = range(1, 25).flatMap((n) => lanes.map((lane) => link.send(lane, n)));
+    await link.runUntil(allDelivered(link, counts), "MULTI-LANE-01 every scope delivered");
+    await link.awaitAll(sends, "MULTI-LANE-01");
+    await link.advance(1000);
+    expectExactDelivery(link, counts, "MULTI-LANE-01");
+    const lanesInLog = link.log.map((entry) => entry.slice(0, entry.indexOf(":")));
+    for (const lane of lanes) {
+        const first = lanesInLog.indexOf(lane);
+        const lastOfOthers = Math.min(...lanes.filter((other) => other !== lane).map((other) => lanesInLog.lastIndexOf(other)));
+        if (first > lastOfOthers)
+            throw new Error(`MULTI-LANE-01: ${lane} started only after another scope had finished`);
+    }
+};
+const stalledLaneDoesNotHoldOthers = async (adapters) => {
+    const link = openLink(adapters);
+    const release = link.gate("A");
+    const aSends = range(1, 100).map((n) => link.send("A", n));
+    const bSends = range(1, 10).map((n) => link.send("B", n));
+    await link.runUntil(allDelivered(link, { B: 10 }), "MULTI-FAIR-01 B delivered while A's receiver is stalled", 20_000);
+    await link.awaitAll(bSends, "MULTI-FAIR-01 B");
+    if (link.delivered("A").length > 0)
+        throw new Error("MULTI-FAIR-01: A delivered through a stalled receiver");
+    release();
+    await link.runUntil(allDelivered(link, { A: 100 }), "MULTI-FAIR-01 A delivered after release");
+    await link.awaitAll(aSends, "MULTI-FAIR-01 A");
+    await link.advance(1000);
+    expectExactDelivery(link, { A: 100, B: 10 }, "MULTI-FAIR-01 stalled lane");
+};
+const MAX_A_FRAMES_BEFORE_B = 4;
+const longLaneDoesNotStarveAnother = async (adapters) => {
+    const stats = { refused: 0, lost: 0, reordered: 0, drops: 0 };
+    const link = openLink(adapters, createCarrierFault("slow", stats));
+    const aSends = range(1, 300).map((n) => link.send("A", n));
+    await link.runUntil(() => link.delivered("A").length >= 20, "MULTI-FAIR-01 A's long lane under way");
+    const before = link.delivered("A").length;
+    const bSend = link.send("B", 1);
+    await link.runUntil(allDelivered(link, { B: 1 }), "MULTI-FAIR-01 B delivered behind A's long lane");
+    const aheadOfB = link.delivered("A").length - before;
+    if (aheadOfB > MAX_A_FRAMES_BEFORE_B) {
+        throw new Error(`MULTI-FAIR-01: ${aheadOfB} of A's frames went ahead of B's one frame (at most ${MAX_A_FRAMES_BEFORE_B})`);
+    }
+    await link.runUntil(allDelivered(link, { A: 300 }), "MULTI-FAIR-01 A's long lane delivered", 600_000);
+    await link.awaitAll([...aSends, bSend], "MULTI-FAIR-01 long lane");
+    await link.advance(1000);
+    expectExactDelivery(link, { A: 300, B: 1 }, "MULTI-FAIR-01 long lane");
+    if (stats.refused === 0)
+        throw new Error("MULTI-FAIR-01: the slow carrier never pushed back");
+};
+const fairness = async (adapters) => {
+    await stalledLaneDoesNotHoldOthers(adapters);
+    await longLaneDoesNotStarveAnother(adapters);
+};
+/** Loses the first data message of `lane`#`seq` on the carrier, once; every other message passes. */
+function loseOnce(decode, lane, seq, stats) {
+    return {
+        wrap: (side) => ({
+            attached: (connection) => side.attached({
+                send: (message) => {
+                    const view = decode(message);
+                    if (stats.lost === 0 && view.kind === "data" && view.lane === lane && view.seq === seq) {
+                        stats.lost += 1;
+                        return true;
+                    }
+                    return connection.send(message);
+                },
+                close: () => connection.close(),
+            }),
+            message: (message) => side.message(message),
+            writable: () => side.writable(),
+            detached: () => side.detached(),
+        }),
+        start: () => { },
+    };
+}
+const LONG_LANE_FRAMES = 400;
+const LONG_LANE_PACE_MS = 10;
+/**
+ * B's only frame is lost while A's paced receiver keeps acknowledging A's long lane. B's resend must not wait for A: the
+ * loss is recovered on B's own deadline, before half of A's frames have gone ahead of it.
+ */
+const lossOnOneLaneIsNotHeldByAnother = async (adapters) => {
+    const stats = { refused: 0, lost: 0, reordered: 0, drops: 0 };
+    const decode = (message) => adapters.transport.decode(message);
+    const link = openLink(adapters, () => loseOnce(decode, "B", 1, stats));
+    link.pace("A", LONG_LANE_PACE_MS);
+    const aSends = range(1, LONG_LANE_FRAMES).map((n) => link.send("A", n));
+    await link.runUntil(() => link.delivered("A").length >= 10, "MULTI-FAIR-02 A's long lane under way");
+    const before = link.delivered("A").length;
+    const bSend = link.send("B", 1);
+    await link.runUntil(allDelivered(link, { B: 1 }), "MULTI-FAIR-02 B delivered after its loss", 600_000);
+    if (stats.lost !== 1)
+        throw new Error(`MULTI-FAIR-02: B#1 was not lost on the carrier (${JSON.stringify(stats)})`);
+    const aheadOfB = link.delivered("A").length - before;
+    if (aheadOfB >= LONG_LANE_FRAMES / 2) {
+        throw new Error(`MULTI-FAIR-02: B's lost frame was resent only after ${aheadOfB} of A's frames (fewer than ${LONG_LANE_FRAMES / 2})`);
+    }
+    await link.runUntil(allDelivered(link, { A: LONG_LANE_FRAMES }), "MULTI-FAIR-02 A delivered", 600_000);
+    await link.awaitAll([...aSends, bSend], "MULTI-FAIR-02");
+    await link.advance(2000);
+    expectExactDelivery(link, { A: LONG_LANE_FRAMES, B: 1 }, "MULTI-FAIR-02");
+};
+export const MULTI_CASES = new Map([
+    ["MULTI-LANE-01", manyLanes],
+    ["MULTI-FAIR-01", fairness],
+    ["MULTI-FAIR-02", lossOnOneLaneIsNotHeldByAnother],
+]);
+//# sourceMappingURL=multi-cases.js.map

package/dist/transport/testing/transport-cases.d.ts

@@ -0,0 +1,6 @@
+import type { CaseImplementation } from "../../conformance/runner.ts";
+import { type TransportCaseAdapters } from "./transport-harness.ts";
+type TransportCase = CaseImplementation<TransportCaseAdapters>;
+export declare const TRANSPORT_CASES: ReadonlyMap<string, TransportCase>;
+export {};
+//# sourceMappingURL=transport-cases.d.ts.map

package/dist/transport/testing/transport-cases.js

@@ -0,0 +1,60 @@
+import { expectEqual } from "../../durable/testing/store-harness.js";
+import { allDelivered, expectExactDelivery, openLink, range } from "./transport-harness.js";
+const order = async (adapters) => {
+    const link = openLink(adapters);
+    const counts = { a: 40, b: 40, c: 40 };
+    const sends = range(1, 40).flatMap((n) => ["a", "b", "c"].map((lane) => link.send(lane, n)));
+    await link.runUntil(allDelivered(link, counts), "TRANSPORT-01 every frame delivered");
+    await link.awaitAll(sends, "TRANSPORT-01");
+    await link.advance(1000);
+    expectExactDelivery(link, counts, "TRANSPORT-01");
+};
+const resume = async (adapters) => {
+    const link = openLink(adapters);
+    const counts = { a: 30, b: 30 };
+    const sends = range(1, 10).flatMap((n) => [link.send("a", n), link.send("b", n)]);
+    await link.runUntil(() => link.delivered("a").length >= 4, "TRANSPORT-02 first frames delivered");
+    link.link.drop();
+    sends.push(...range(11, 20).flatMap((n) => [link.send("a", n), link.send("b", n)]));
+    await link.advance(500);
+    if (link.sender.inFlight("a") + link.sender.inFlight("b") === 0) {
+        throw new Error("TRANSPORT-02: expected unacknowledged frames while the carrier is down");
+    }
+    link.link.connect();
+    await link.runUntil(() => link.delivered("a").length >= 15, "TRANSPORT-02 resumed after the first re-attach");
+    link.link.drop();
+    sends.push(...range(21, 30).flatMap((n) => [link.send("a", n), link.send("b", n)]));
+    link.link.connect();
+    await link.runUntil(allDelivered(link, counts), "TRANSPORT-02 every frame delivered after two re-attaches");
+    await link.awaitAll(sends, "TRANSPORT-02");
+    await link.advance(1000);
+    expectExactDelivery(link, counts, "TRANSPORT-02");
+};
+const backpressure = async (adapters) => {
+    const link = openLink(adapters);
+    const release = link.gate("slow");
+    const resolved = [];
+    const sends = range(1, 200).map((n) => link.send("slow", n).then(() => void resolved.push(n)));
+    await link.advance(2000);
+    const admitted = resolved.length;
+    if (admitted === 0 || admitted >= 200) {
+        throw new Error(`TRANSPORT-03: a stalled receiver must bound the senders, but ${admitted} of 200 sends resolved`);
+    }
+    await link.advance(2000);
+    expectEqual(resolved.length, admitted, "TRANSPORT-03 the bound holds while the receiver stays stalled");
+    expectEqual(link.delivered("slow"), [], "TRANSPORT-03 nothing delivered while the receiver is stalled");
+    if (link.sender.inFlight("slow") > admitted)
+        throw new Error("TRANSPORT-03: more in flight than admitted");
+    release();
+    await link.runUntil(allDelivered(link, { slow: 200 }), "TRANSPORT-03 every frame delivered after release");
+    await link.awaitAll(sends, "TRANSPORT-03");
+    expectEqual(resolved, range(1, 200), "TRANSPORT-03 sends resolve in send order");
+    await link.advance(1000);
+    expectExactDelivery(link, { slow: 200 }, "TRANSPORT-03");
+};
+export const TRANSPORT_CASES = new Map([
+    ["TRANSPORT-01", order],
+    ["TRANSPORT-02", resume],
+    ["TRANSPORT-03", backpressure],
+]);
+//# sourceMappingURL=transport-cases.js.map

package/dist/transport/testing/transport-harness.d.ts

@@ -0,0 +1,53 @@
+import { type ManualTimers } from "../../durable/testing/manual-timers.ts";
+import { type CarrierLink } from "../in-process-carrier.ts";
+import type { CarrierSide, TransportClock, TransportSide } from "../transport.ts";
+/** What a conformance host's decoder reports about one carrier message; data and ACK sequence numbers start at 1. */
+export type WireView = {
+    readonly kind: "data" | "ack";
+    readonly lane: string;
+    readonly seq: number;
+} | {
+    readonly kind: "other";
+};
+/** What a host provides to the TRANSPORT, MULTI-LANE/FAIR and FAULT-TRANSPORT cases. */
+export interface TransportConformanceAdapter {
+    /** A new transport endpoint scheduling on `clock`; the cases attach two of them through an in-process carrier. */
+    createSide(clock: TransportClock): TransportSide;
+    /** Reads the lane and sequence number of a carrier message, so the cases can check resume from the last ACK. */
+    decode(message: unknown): WireView;
+}
+export interface TransportCaseAdapters {
+    readonly transport: TransportConformanceAdapter;
+    /** The platform whose local endpoint naming the link uses (`win32` names a pipe). */
+    readonly platform: string;
+}
+/** A fault on the carrier path: it wraps each side's view of the carrier and may drive the link. */
+export interface CarrierFault {
+    wrap(side: CarrierSide): CarrierSide;
+    start(link: CarrierLink): void;
+}
+export interface TestLink {
+    readonly sender: TransportSide;
+    readonly link: CarrierLink;
+    readonly timers: ManualTimers;
+    /** Global delivery order, as `lane:n`. */
+    readonly log: readonly string[];
+    /** Every data frame sent again after the sender had seen its ACK. */
+    readonly violations: readonly string[];
+    send(lane: string, n: number): Promise<void>;
+    delivered(lane: string): readonly number[];
+    /** Holds the receiver on `lane` (from its next frame) until the returned release is called. */
+    gate(lane: string): () => void;
+    /** Makes the receiver take `ms` of transport time for each frame on `lane` (from its next frame). */
+    pace(lane: string, ms: number): void;
+    runUntil(done: () => boolean, what: string, budgetMs?: number): Promise<void>;
+    /** Advances transport time until every promise settles; a rejection fails the case. */
+    awaitAll(promises: readonly Promise<unknown>[], what: string): Promise<void>;
+    advance(ms: number): Promise<void>;
+}
+export declare function openLink(adapters: TransportCaseAdapters, fault?: (timers: ManualTimers) => CarrierFault): TestLink;
+export declare const range: (from: number, to: number) => number[];
+/** Every lane got exactly 1..count, in order, once; nothing is left unacknowledged; nothing acknowledged was re-sent. */
+export declare function expectExactDelivery(link: TestLink, counts: Readonly<Record<string, number>>, what: string): void;
+export declare const allDelivered: (link: TestLink, counts: Readonly<Record<string, number>>) => () => boolean;
+//# sourceMappingURL=transport-harness.d.ts.map

package/dist/transport/testing/transport-harness.js

@@ -0,0 +1,127 @@
+import { createManualTimers } from "../../durable/testing/manual-timers.js";
+import { expectEqual } from "../../durable/testing/store-harness.js";
+import { createInProcessNetwork } from "../in-process-carrier.js";
+import { localEndpoint } from "../local-endpoint.js";
+const TICK_MS = 5;
+const DRAIN_TURNS = 32;
+const drainMicrotasks = async () => {
+    for (let turn = 0; turn < DRAIN_TURNS; turn++)
+        await Promise.resolve();
+};
+function tap(side, decode, violations) {
+    const acked = new Map();
+    return {
+        attached: (connection) => side.attached({
+            send: (message) => {
+                const view = decode(message);
+                if (view.kind === "data" && view.seq <= (acked.get(view.lane) ?? 0)) {
+                    violations.push(`${view.lane}#${view.seq} sent again after its ACK`);
+                }
+                return connection.send(message);
+            },
+            close: () => connection.close(),
+        }),
+        message: (message) => {
+            const view = decode(message);
+            if (view.kind === "ack")
+                acked.set(view.lane, Math.max(acked.get(view.lane) ?? 0, view.seq));
+            side.message(message);
+        },
+        writable: () => side.writable(),
+        detached: () => side.detached(),
+    };
+}
+export function openLink(adapters, fault) {
+    const timers = createManualTimers(0);
+    const network = createInProcessNetwork({ schedule: (deliver) => void timers.setTimer(deliver, 0) });
+    const sender = adapters.transport.createSide(timers);
+    const receiver = adapters.transport.createSide(timers);
+    const violations = [];
+    const log = [];
+    const received = new Map();
+    const gates = new Map();
+    const paces = new Map();
+    const installed = fault?.(timers);
+    const outer = (side) => {
+        const tapped = tap(side, (message) => adapters.transport.decode(message), violations);
+        return installed === undefined ? tapped : installed.wrap(tapped);
+    };
+    const endpoint = localEndpoint(adapters.platform, "transport-conformance", "/run/senpi-conformance");
+    network.listen(endpoint, outer(receiver));
+    const link = network.dial(endpoint, outer(sender));
+    const decoder = new TextDecoder();
+    receiver.onFrame(async (frame) => {
+        await gates.get(frame.lane)?.promise;
+        const paceMs = paces.get(frame.lane);
+        if (paceMs !== undefined)
+            await new Promise((resolve) => void timers.setTimer(resolve, paceMs));
+        const n = Number(decoder.decode(frame.payload));
+        received.set(frame.lane, [...(received.get(frame.lane) ?? []), n]);
+        log.push(`${frame.lane}:${n}`);
+    });
+    link.connect();
+    installed?.start(link);
+    const advance = async (ms) => {
+        const end = timers.now() + ms;
+        while (timers.now() < end) {
+            await timers.advanceTo(Math.min(end, timers.now() + TICK_MS));
+            await drainMicrotasks();
+        }
+    };
+    const encoder = new TextEncoder();
+    const runUntil = async (done, what, budgetMs = 120_000) => {
+        const end = timers.now() + budgetMs;
+        while (!done()) {
+            if (timers.now() >= end) {
+                const counts = [...received].map(([lane, ns]) => `${lane}=${ns.length}`).join(" ");
+                throw new Error(`${what}: not reached within ${budgetMs} ms of transport time (delivered ${counts})`);
+            }
+            await advance(TICK_MS);
+        }
+    };
+    return {
+        sender,
+        link,
+        timers,
+        log,
+        violations,
+        send: (lane, n) => sender.send(lane, encoder.encode(String(n))),
+        delivered: (lane) => received.get(lane) ?? [],
+        gate(lane) {
+            const gate = Promise.withResolvers();
+            gates.set(lane, gate);
+            return () => {
+                gates.delete(lane);
+                gate.resolve();
+            };
+        },
+        pace(lane, ms) {
+            paces.set(lane, ms);
+        },
+        runUntil,
+        async awaitAll(promises, what) {
+            let settled = 0;
+            let failure;
+            for (const promise of promises) {
+                promise.then(() => void (settled += 1), (error) => {
+                    settled += 1;
+                    failure ??= error;
+                });
+            }
+            await runUntil(() => settled === promises.length, `${what}: every send settled`);
+            if (failure !== undefined)
+                throw failure;
+        },
+        advance,
+    };
+}
+export const range = (from, to) => Array.from({ length: to - from + 1 }, (_, i) => from + i);
+/** Every lane got exactly 1..count, in order, once; nothing is left unacknowledged; nothing acknowledged was re-sent. */
+export function expectExactDelivery(link, counts, what) {
+    const lanes = Object.keys(counts);
+    expectEqual(lanes.map((lane) => link.delivered(lane)), lanes.map((lane) => range(1, counts[lane] ?? 0)), `${what}: each lane delivered in order, once`);
+    expectEqual(lanes.map((lane) => link.sender.inFlight(lane)), lanes.map(() => 0), `${what}: nothing in flight`);
+    expectEqual(link.violations, [], `${what}: resume starts after each lane's last ACK`);
+}
+export const allDelivered = (link, counts) => () => Object.entries(counts).every(([lane, count]) => link.delivered(lane).length >= count);
+//# sourceMappingURL=transport-harness.js.map

package/dist/transport/transport.d.ts

@@ -0,0 +1,60 @@
+/**
+ * The Transport contract of the durable core (packages/agent/docs/durable-core-adr.md, "Transport").
+ *
+ * A transport delivers opaque payloads between two endpoints on named lanes (one lane per scope). It owns per-lane order,
+ * exactly-once delivery of each frame while both endpoints live, resume after the carrier drops and re-attaches, and
+ * backpressure. Loops, hands, command IDs, epochs, deduplication of commands, consent, fencing and credentials are
+ * endpoint duties; a transport never inspects a payload.
+ */
+/** One delivered frame: the lane it was sent on and its opaque payload. */
+export interface TransportFrame {
+    readonly lane: string;
+    readonly payload: Uint8Array;
+}
+/** Receives frames. A lane's next frame is delivered only after this settles for the previous one; lanes are independent. */
+export type FrameHandler = (frame: TransportFrame) => void | Promise<void>;
+/** One endpoint of a transport link. */
+export interface Transport {
+    /**
+     * Queues `payload` on `lane`. Resolves once the frame is inside the lane's send window, so a lane whose receiver falls
+     * behind holds its own senders and nobody else's. Rejects with {@link TransportClosedError} after `close()`.
+     */
+    send(lane: string, payload: Uint8Array): Promise<void>;
+    /** Sets the receiver. Frames that arrived earlier are delivered once it is set. */
+    onFrame(handler: FrameHandler): void;
+    /** Frames on `lane` that were sent and not yet acknowledged by the peer. */
+    inFlight(lane: string): number;
+    close(): void;
+}
+/**
+ * A message channel under a transport (in process, a local socket, the relay). It is ordered while it lasts, may drop
+ * at any time, and under faults may lose or delay messages. Messages are opaque to it.
+ */
+export interface CarrierConnection {
+    /** Hands `message` to the carrier. `false` means it was not taken; the side waits for `writable()` and sends again. */
+    send(message: unknown): boolean;
+    close(): void;
+}
+/** What a carrier calls on the endpoint it serves. */
+export interface CarrierSide {
+    /** A new connection is up (the first, or a re-attach after a drop). */
+    attached(connection: CarrierConnection): void;
+    message(message: unknown): void;
+    /** The current connection takes messages again after a refused `send`. */
+    writable(): void;
+    /** The current connection is gone; anything in flight on it is lost. */
+    detached(): void;
+}
+/** A transport endpoint as a carrier sees it. */
+export interface TransportSide extends Transport, CarrierSide {
+}
+/** The clock a transport schedules on; tests pass manual timers. */
+export interface TransportClock {
+    now(): number;
+    /** Runs `callback` after `ms`; the returned function cancels it. */
+    setTimer(callback: () => unknown, ms: number): () => void;
+}
+export declare class TransportClosedError extends Error {
+    constructor();
+}
+//# sourceMappingURL=transport.d.ts.map

package/dist/transport/transport.js

@@ -0,0 +1,15 @@
+/**
+ * The Transport contract of the durable core (packages/agent/docs/durable-core-adr.md, "Transport").
+ *
+ * A transport delivers opaque payloads between two endpoints on named lanes (one lane per scope). It owns per-lane order,
+ * exactly-once delivery of each frame while both endpoints live, resume after the carrier drops and re-attaches, and
+ * backpressure. Loops, hands, command IDs, epochs, deduplication of commands, consent, fencing and credentials are
+ * endpoint duties; a transport never inspects a payload.
+ */
+export class TransportClosedError extends Error {
+    constructor() {
+        super("transport closed");
+        this.name = "TransportClosedError";
+    }
+}
+//# sourceMappingURL=transport.js.map

package/dist/types.d.ts

@@ -185,6 +185,12 @@ export interface AgentLoopConfig extends SimpleStreamOptions {
      * Unset or non-positive values disable the start bound.
      */
     streamStartTimeoutMs?: number;
+    /**
+     * Bytes the provider reports through `onTransportActivity` (SSE pings, keep-alive comments) keep the start and
+     * idle bounds from firing while they keep arriving within one bound. This caps how long keep-alives alone may
+     * hold a request without any assistant event. Unset or non-positive values leave keep-alives unbounded.
+     */
+    streamKeepAliveTimeoutMs?: number;
     /** Provider/SDK timeout override for only the first request in this loop invocation. */
     initialRequestTimeoutMs?: number;
     /** Stream-start timeout override for only the first request in this loop invocation. */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-agent-core",
-	"version": "2026.10.27-2",
+	"version": "2026.10.30-2",
 	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -14,6 +14,10 @@
 			"types": "./dist/node.d.ts",
 			"import": "./dist/node.js"
 		},
+		"./conformance": {
+			"types": "./dist/conformance/index.d.ts",
+			"import": "./dist/conformance/index.js"
+		},
 		"./harness/context": {
 			"types": "./dist/harness/context.d.ts",
 			"import": "./dist/harness/context.js"
@@ -38,6 +42,10 @@
 			"types": "./dist/harness/session/testing/index.d.ts",
 			"import": "./dist/harness/session/testing/index.js"
 		},
+		"./testing/win32-sim": {
+			"types": "./dist/testing/win32-sim.d.ts",
+			"import": "./dist/testing/win32-sim.js"
+		},
 		"./package.json": "./package.json"
 	},
 	"files": [
@@ -62,8 +70,8 @@
 	},
 	"dependencies": {
 		"@earendil-works/chord": "0.99.1",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.27-2",
-		"@earendil-works/pi-telemetry": "npm:@code-yeongyu/senpi-telemetry@2026.10.27-2",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.30-2",
+		"@earendil-works/pi-telemetry": "npm:@code-yeongyu/senpi-telemetry@2026.10.30-2",
 		"diff": "9.0.0",
 		"ignore": "7.0.9",
 		"typebox": "1.3.34",