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

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

@@ -546,6 +546,7 @@ export type AgentEvent = {
 } | {
     type: "message_start";
     message: AgentMessage;
+    streaming?: true;
 } | {
     type: "message_update";
     message: AgentMessage;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-agent-core",
-	"version": "2026.10.27-1",
+	"version": "2026.10.30-1",
 	"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-1",
-		"@earendil-works/pi-telemetry": "npm:@code-yeongyu/senpi-telemetry@2026.10.27-1",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.30-1",
+		"@earendil-works/pi-telemetry": "npm:@code-yeongyu/senpi-telemetry@2026.10.30-1",
 		"diff": "9.0.0",
 		"ignore": "7.0.9",
 		"typebox": "1.3.34",