akemon 0.3.2 → 0.3.3

package/dist/role-module.test.js

@@ -1,208 +0,0 @@
-import { describe, it, before, after } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { parseRole, parseProduct, resolveRoles, resolveProduct, buildRoleContext, } from "./role-module.js";
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function makeRole(name, triggers = [], extras = {}) {
-    return { name, description: "", triggers, include: [], exclude: [], customRules: "", raw: "", ...extras };
-}
-function makeProduct(name, extras = {}) {
-    return { name, playbook: "", productIds: [], raw: "", ...extras };
-}
-function makePlaybook(name, raw = "") {
-    return { name, raw };
-}
-// ---------------------------------------------------------------------------
-// Pure parsing — parseRole
-// ---------------------------------------------------------------------------
-describe("parseRole — pure parsing", () => {
-    it("extracts description, triggers, include, exclude from standard role md", () => {
-        const raw = `# Sales Rep
-
-Expert in closing deals and building client relationships.
-
-## 激活
-- trigger:order
-- trigger:chat:public
-
-## 上下文范围
-include: buyer history, product catalog
-exclude: owner notes, private diary
-`;
-        const role = parseRole("sales-rep", raw);
-        assert.equal(role.name, "sales-rep");
-        assert.equal(role.description, "Expert in closing deals and building client relationships.");
-        assert.deepEqual(role.triggers, ["trigger:order", "trigger:chat:public"]);
-        assert.deepEqual(role.include, ["buyer history", "product catalog"]);
-        assert.deepEqual(role.exclude, ["owner notes", "private diary"]);
-    });
-    it("returns empty arrays for include/exclude/triggers when sections are missing", () => {
-        const raw = `# Simple Role
-
-A minimal role with no activation or context sections.
-`;
-        const role = parseRole("simple", raw);
-        assert.deepEqual(role.triggers, []);
-        assert.deepEqual(role.include, []);
-        assert.deepEqual(role.exclude, []);
-        assert.equal(role.description, "A minimal role with no activation or context sections.");
-    });
-    it("collects content outside 激活 and 上下文范围 into customRules", () => {
-        const raw = `# Worker
-
-Efficient task executor.
-
-## 激活
-- trigger:agent_call
-
-## Operating Principles
-Always reply in the language the user writes in.
-Be concise and accurate.
-
-## Tone
-Professional and neutral.
-`;
-        const role = parseRole("worker", raw);
-        assert.ok(role.customRules.includes("Always reply in the language the user writes in."), "should include content from ## Operating Principles");
-        assert.ok(role.customRules.includes("Professional and neutral."), "should include content from ## Tone");
-        // triggers and standard sections should not bleed in
-        assert.deepEqual(role.triggers, ["trigger:agent_call"]);
-    });
-});
-// ---------------------------------------------------------------------------
-// Pure parsing — parseProduct
-// ---------------------------------------------------------------------------
-describe("parseProduct — pure parsing", () => {
-    it("extracts playbook and multiple productIds correctly", () => {
-        const raw = `# Widget Pro
-
-## playbook
-widget-strategy
-
-## products
-- p_abc123
-- p_def456
-- p_ghi789
-`;
-        const product = parseProduct("widget-pro", raw);
-        assert.equal(product.name, "widget-pro");
-        assert.equal(product.playbook, "widget-strategy");
-        assert.deepEqual(product.productIds, ["p_abc123", "p_def456", "p_ghi789"]);
-    });
-    it("returns empty productIds when ## products section is absent", () => {
-        const raw = `# No Products
-
-## playbook
-some-playbook
-`;
-        const product = parseProduct("no-products", raw);
-        assert.deepEqual(product.productIds, []);
-        assert.equal(product.playbook, "some-playbook");
-    });
-    it("returns empty string for playbook when ## playbook section is absent", () => {
-        const raw = `# No Playbook
-
-## products
-- p_xyz
-`;
-        const product = parseProduct("no-playbook", raw);
-        assert.equal(product.playbook, "");
-        assert.deepEqual(product.productIds, ["p_xyz"]);
-    });
-});
-// ---------------------------------------------------------------------------
-// Resolution — resolveRoles
-// ---------------------------------------------------------------------------
-describe("resolveRoles — resolution", () => {
-    it("partial trigger match: first match is primary, remaining are secondary", () => {
-        const roles = [
-            makeRole("general-chat", ["trigger:chat"]),
-            makeRole("owner-companion", ["trigger:chat:owner"]),
-        ];
-        // "trigger:chat:owner" includes "trigger:chat" → both match
-        const { primary, secondary } = resolveRoles(roles, "trigger:chat:owner");
-        assert.equal(primary?.name, "general-chat");
-        assert.equal(secondary.length, 1);
-        assert.equal(secondary[0].name, "owner-companion");
-    });
-    it("returns primary=null and empty secondary when no trigger matches", () => {
-        const roles = [
-            makeRole("merchant", ["trigger:order"]),
-            makeRole("companion", ["trigger:chat:owner"]),
-        ];
-        const { primary, secondary } = resolveRoles(roles, "trigger:nonexistent");
-        assert.equal(primary, null);
-        assert.deepEqual(secondary, []);
-    });
-});
-// ---------------------------------------------------------------------------
-// Resolution — resolveProduct
-// ---------------------------------------------------------------------------
-describe("resolveProduct — resolution", () => {
-    const products = [
-        makeProduct("Alpha Product", { productIds: ["p_alpha"], playbook: "alpha-pb" }),
-        makeProduct("Beta Service", { productIds: ["p_beta"], playbook: "beta-pb" }),
-    ];
-    const playbooks = [
-        makePlaybook("alpha-pb", "# Alpha Playbook\nContent."),
-        makePlaybook("beta-pb", "# Beta Playbook\nContent."),
-    ];
-    it("productId takes priority over productName when both are provided", () => {
-        // productId matches "Alpha Product", productName matches "Beta Service"
-        const result = resolveProduct(products, playbooks, "Beta Service", "p_alpha");
-        assert.ok(result !== null);
-        assert.equal(result.product.name, "Alpha Product");
-    });
-    it("fuzzy name match is case- and separator-insensitive", () => {
-        // "alpha_product" → normalized "alphaproduct"
-        // "Alpha Product" → normalized "alphaproduct" → exact match
-        const result = resolveProduct(products, playbooks, "alpha_product");
-        assert.ok(result !== null);
-        assert.equal(result.product.name, "Alpha Product");
-    });
-    it("returns null when neither productId nor productName matches", () => {
-        const result = resolveProduct(products, playbooks, "Completely Unknown");
-        assert.equal(result, null);
-    });
-    it("playbook lookup is case-insensitive", () => {
-        const prods = [makeProduct("my-widget", { playbook: "My-Playbook", productIds: [] })];
-        const pbs = [makePlaybook("my-playbook", "# PB Content")];
-        const result = resolveProduct(prods, pbs, "my-widget");
-        assert.ok(result !== null);
-        assert.ok(result.playbook !== null);
-        assert.equal(result.playbook?.name, "my-playbook");
-    });
-});
-// ---------------------------------------------------------------------------
-// buildRoleContext — real fs with tmp dir
-// ---------------------------------------------------------------------------
-describe("buildRoleContext — fs integration", () => {
-    let tmpDir;
-    const agentName = "test-agent";
-    before(async () => {
-        tmpDir = await mkdtemp(join(tmpdir(), "akemon-test-"));
-        const selfBase = join(tmpDir, ".akemon", "agents", agentName, "self");
-        await mkdir(join(selfBase, "roles"), { recursive: true });
-        await mkdir(join(selfBase, "playbooks"), { recursive: true });
-        await mkdir(join(selfBase, "products"), { recursive: true });
-        await writeFile(join(selfBase, "roles", "worker.md"), `# 工人\n执行任务的专业角色。\n\n## 激活\n- trigger:order\n`);
-        await writeFile(join(selfBase, "playbooks", "strategy.md"), `# Strategy\n核心策略内容。\n`);
-        await writeFile(join(selfBase, "products", "widget.md"), `# Widget\n\n## playbook\nstrategy\n\n## products\n- p_1234\n`);
-    });
-    after(async () => {
-        await rm(tmpDir, { recursive: true, force: true });
-    });
-    it("matching trigger produces output with [Active role: ...]", async () => {
-        const result = await buildRoleContext(tmpDir, agentName, "trigger:order:001");
-        assert.ok(result.includes("[Active role: worker]"), `expected '[Active role: worker]' in:\n${result}`);
-    });
-    it("passing productName produces output with [Product: ...] and [Playbook: ...]", async () => {
-        const result = await buildRoleContext(tmpDir, agentName, "trigger:other", "widget");
-        assert.ok(result.includes("[Product: widget]"), `expected '[Product: widget]' in:\n${result}`);
-        assert.ok(result.includes("[Playbook: strategy]"), `expected '[Playbook: strategy]' in:\n${result}`);
-    });
-});

package/dist/software-agent-http.test.js

@@ -1,108 +0,0 @@
-import assert from "node:assert/strict";
-import { Readable, Writable } from "node:stream";
-import { describe, it } from "node:test";
-import { handleSoftwareAgentRunHttp } from "./server.js";
-class TestResponse extends Writable {
-    statusCode = 200;
-    headers = {};
-    body = "";
-    writeHead(statusCode, headers) {
-        this.statusCode = statusCode;
-        this.headers = headers || {};
-        return this;
-    }
-    end(chunk, encoding, callback) {
-        if (chunk)
-            this.body += Buffer.isBuffer(chunk) ? chunk.toString("utf-8") : String(chunk);
-        return super.end(callback || (typeof encoding === "function" ? encoding : undefined));
-    }
-    _write(chunk, _encoding, callback) {
-        this.body += chunk.toString("utf-8");
-        callback();
-    }
-}
-async function callSoftwareAgentEndpoint(softwareAgent, body, token) {
-    const rawBody = JSON.stringify(body);
-    const req = Readable.from([Buffer.from(rawBody)]);
-    Object.assign(req, {
-        method: "POST",
-        url: "/self/software-agent/run",
-        headers: {
-            ...(token ? { authorization: `Bearer ${token}` } : {}),
-            "content-type": "application/json",
-        },
-    });
-    const res = new TestResponse();
-    await handleSoftwareAgentRunHttp(req, res, {
-        options: { secretKey: "owner-secret", key: "legacy-owner-key" },
-        workdir: "/repo",
-        softwareAgent,
-    });
-    return {
-        statusCode: res.statusCode,
-        body: res.body ? JSON.parse(res.body) : {},
-    };
-}
-describe("software-agent HTTP endpoint", () => {
-    it("requires an owner token", async () => {
-        let calls = 0;
-        const res = await callSoftwareAgentEndpoint({
-            async sendTask(envelope) {
-                calls++;
-                return successResult(envelope);
-            },
-        }, { goal: "inspect repo" });
-        assert.equal(res.statusCode, 401);
-        assert.match(res.body.error, /Owner token required/);
-        assert.equal(calls, 0);
-    });
-    it("forwards a validated owner envelope to the software agent", async () => {
-        let received = null;
-        const res = await callSoftwareAgentEndpoint({
-            async sendTask(envelope) {
-                received = envelope;
-                return successResult(envelope);
-            },
-        }, {
-            goal: "  inspect repo  ",
-            roleScope: "owner",
-            memoryScope: "owner",
-            riskLevel: "low",
-            forbiddenActions: ["make network requests"],
-            timeoutMs: 5000,
-        }, "owner-secret");
-        assert.equal(res.statusCode, 200);
-        assert.equal(res.body.success, true);
-        assert.ok(received);
-        const envelope = received;
-        assert.equal(envelope.goal, "inspect repo");
-        assert.equal(envelope.riskLevel, "low");
-        assert.equal(envelope.timeoutMs, 5000);
-        assert.deepEqual(envelope.forbiddenActions, [
-            "read Akemon private memory outside this envelope",
-            "access files outside the stated workdir unless explicitly needed and reported",
-            "make network requests",
-        ]);
-    });
-    it("rejects invalid envelope fields before calling the software agent", async () => {
-        let calls = 0;
-        const res = await callSoftwareAgentEndpoint({
-            async sendTask(envelope) {
-                calls++;
-                return successResult(envelope);
-            },
-        }, { goal: "inspect repo", roleScope: "friend" }, "owner-secret");
-        assert.equal(res.statusCode, 400);
-        assert.match(res.body.error, /Invalid roleScope/);
-        assert.equal(calls, 0);
-    });
-});
-function successResult(envelope) {
-    return {
-        success: true,
-        taskId: envelope.taskId || "task-from-test",
-        output: "ok",
-        exitCode: 0,
-        durationMs: 1,
-    };
-}

package/dist/software-agent-peripheral.test.js

@@ -1,187 +0,0 @@
-import assert from "node:assert/strict";
-import { EventEmitter } from "node:events";
-import { describe, it } from "node:test";
-import { PassThrough } from "node:stream";
-import { CodexSoftwareAgentPeripheral, buildTaskEnvelopePrompt, createOwnerTaskEnvelope, } from "./software-agent-peripheral.js";
-import { SimpleEventBus } from "./event-bus.js";
-import { SIG } from "./types.js";
-function createFakeChild() {
-    const child = new EventEmitter();
-    child.stdin = new PassThrough();
-    child.stdout = new PassThrough();
-    child.stderr = new PassThrough();
-    Object.defineProperty(child, "pid", { value: 23456, configurable: true });
-    child.unref = () => child;
-    return child;
-}
-function baseEnvelope(overrides = {}) {
-    return {
-        taskId: "sw-test-1",
-        sourceModule: "task",
-        purpose: "dogfood coding task",
-        goal: "Inspect the repo and summarize the event bus implementation.",
-        workdir: "/tmp/akemon",
-        roleScope: "owner",
-        memoryScope: "owner",
-        riskLevel: "medium",
-        allowedActions: ["read repository files", "run tests"],
-        forbiddenActions: ["read owner private notes outside this envelope"],
-        memorySummary: "Visible context only.",
-        deliverable: "Concise engineering report.",
-        ...overrides,
-    };
-}
-describe("buildTaskEnvelopePrompt", () => {
-    it("renders envelope fields, visible memory, boundaries, and deliverable", () => {
-        const prompt = buildTaskEnvelopePrompt(baseEnvelope());
-        assert.match(prompt, /Task ID: sw-test-1/);
-        assert.match(prompt, /Source module: task/);
-        assert.match(prompt, /Role scope: owner/);
-        assert.match(prompt, /Memory scope: owner/);
-        assert.match(prompt, /Risk level: medium/);
-        assert.match(prompt, /Workdir: \/tmp\/akemon/);
-        assert.match(prompt, /Visible context only\./);
-        assert.match(prompt, /- read repository files/);
-        assert.match(prompt, /- read owner private notes outside this envelope/);
-        assert.match(prompt, /Concise engineering report\./);
-        assert.match(prompt, /Do not attempt to read Akemon private memory outside the visible context/);
-    });
-});
-describe("createOwnerTaskEnvelope", () => {
-    it("builds conservative owner defaults from a minimal body", () => {
-        const envelope = createOwnerTaskEnvelope({ goal: "  inspect repo  " }, "/repo");
-        assert.equal(envelope.sourceModule, "owner-http");
-        assert.equal(envelope.goal, "inspect repo");
-        assert.equal(envelope.workdir, "/repo");
-        assert.equal(envelope.roleScope, "owner");
-        assert.equal(envelope.memoryScope, "owner");
-        assert.equal(envelope.riskLevel, "medium");
-        assert.deepEqual(envelope.allowedActions, ["read repository files", "edit files in workdir", "run project tests"]);
-        assert.ok(envelope.forbiddenActions?.some((item) => item.includes("private memory")));
-    });
-    it("keeps baseline forbidden boundaries when caller adds restrictions", () => {
-        const envelope = createOwnerTaskEnvelope({
-            goal: "inspect repo",
-            forbiddenActions: ["make network requests", "read Akemon private memory outside this envelope"],
-        }, "/repo");
-        assert.deepEqual(envelope.forbiddenActions, [
-            "read Akemon private memory outside this envelope",
-            "access files outside the stated workdir unless explicitly needed and reported",
-            "make network requests",
-        ]);
-    });
-    it("rejects empty goals", () => {
-        assert.throws(() => createOwnerTaskEnvelope({ goal: "   " }, "/repo"), /Missing required string field: goal/);
-    });
-    it("rejects invalid scope, action, and timeout fields", () => {
-        assert.throws(() => createOwnerTaskEnvelope({ goal: "inspect repo", roleScope: "friend" }, "/repo"), /Invalid roleScope/);
-        assert.throws(() => createOwnerTaskEnvelope({ goal: "inspect repo", memoryScope: "private" }, "/repo"), /Invalid memoryScope/);
-        assert.throws(() => createOwnerTaskEnvelope({ goal: "inspect repo", riskLevel: "critical" }, "/repo"), /Invalid riskLevel/);
-        assert.throws(() => createOwnerTaskEnvelope({ goal: "inspect repo", allowedActions: ["read", ""] }, "/repo"), /Invalid allowedActions\[1\]/);
-        assert.throws(() => createOwnerTaskEnvelope({ goal: "inspect repo", timeoutMs: 0 }, "/repo"), /Invalid timeoutMs/);
-    });
-});
-describe("CodexSoftwareAgentPeripheral", () => {
-    it("runs codex exec with an envelope over stdin and streams lifecycle events", async () => {
-        const streamEvents = [];
-        const busEvents = [];
-        let writtenPrompt = "";
-        let spawnedChild = null;
-        const bus = new SimpleEventBus();
-        bus.on(SIG.TASK_STARTED, (signal) => {
-            busEvents.push(`${signal.type}:${signal.data.taskId}`);
-        });
-        bus.on(SIG.TASK_COMPLETED, (signal) => {
-            busEvents.push(`${signal.type}:${signal.data.taskId}`);
-        });
-        const peripheral = new CodexSoftwareAgentPeripheral({
-            workdir: "/tmp/akemon",
-            command: "codex",
-            spawnImpl: ((cmd, args, opts) => {
-                assert.equal(cmd, "codex");
-                assert.deepEqual(args, [
-                    "exec",
-                    "--skip-git-repo-check",
-                    "--color", "never",
-                    "-s", "workspace-write",
-                    "-C", "/tmp/akemon",
-                    "-",
-                ]);
-                assert.equal(opts?.cwd, "/tmp/akemon");
-                const child = createFakeChild();
-                spawnedChild = child;
-                child.stdin?.on("data", (chunk) => {
-                    writtenPrompt += chunk.toString("utf8");
-                });
-                queueMicrotask(() => {
-                    child.stdout?.emit("data", Buffer.from("result "));
-                    child.stderr?.emit("data", Buffer.from("note"));
-                    child.stdout?.emit("data", Buffer.from("ok"));
-                    child.emit("close", 0);
-                });
-                return child;
-            }),
-            taskRelay: {
-                sendTaskStart(taskId, origin, cmd) {
-                    streamEvents.push({ type: "start", taskId, origin, cmd });
-                },
-                sendTaskStream(taskId, stream, chunk) {
-                    streamEvents.push({ type: "stream", taskId, stream, chunk });
-                },
-                sendTaskEnd(taskId, exitCode, durationMs) {
-                    streamEvents.push({ type: "end", taskId, exitCode, durationMs });
-                },
-            },
-        });
-        await peripheral.start(bus);
-        const result = await peripheral.sendTask(baseEnvelope());
-        assert.ok(spawnedChild, "spawn should be called");
-        assert.equal(result.success, true);
-        assert.equal(result.taskId, "sw-test-1");
-        assert.equal(result.output, "result ok");
-        assert.equal(result.exitCode, 0);
-        assert.match(writtenPrompt, /Akemon Software Peripheral Task Envelope/);
-        assert.match(writtenPrompt, /Goal:\nInspect the repo/);
-        assert.match(writtenPrompt, /Visible context only\./);
-        assert.deepEqual(streamEvents.slice(0, 4), [
-            {
-                type: "start",
-                taskId: "sw-test-1",
-                origin: "software_agent",
-                cmd: "codex exec --skip-git-repo-check --color never -s workspace-write -C /tmp/akemon -",
-            },
-            { type: "stream", taskId: "sw-test-1", stream: "stdout", chunk: "result " },
-            { type: "stream", taskId: "sw-test-1", stream: "stderr", chunk: "note" },
-            { type: "stream", taskId: "sw-test-1", stream: "stdout", chunk: "ok" },
-        ]);
-        const end = streamEvents[4];
-        assert.equal(end?.type, "end");
-        if (end?.type === "end") {
-            assert.equal(end.taskId, "sw-test-1");
-            assert.equal(end.exitCode, 0);
-            assert.ok(end.durationMs >= 0);
-        }
-        assert.deepEqual(busEvents, [
-            "task:started:sw-test-1",
-            "task:completed:sw-test-1",
-        ]);
-    });
-    it("rejects concurrent tasks while a codex run is active", async () => {
-        const peripheral = new CodexSoftwareAgentPeripheral({
-            workdir: "/tmp/akemon",
-            spawnImpl: (() => {
-                const child = createFakeChild();
-                setTimeout(() => child.emit("close", 0), 10);
-                return child;
-            }),
-            taskRelay: {
-                sendTaskStart() { },
-                sendTaskStream() { },
-                sendTaskEnd() { },
-            },
-        });
-        const first = peripheral.sendTask(baseEnvelope({ taskId: "first" }));
-        await assert.rejects(() => peripheral.sendTask(baseEnvelope({ taskId: "second" })), /Software agent busy/);
-        await first;
-    });
-});

package/dist/task-helpers.test.js

@@ -1,88 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { sortByQuadrant, dedupeWorkItems, computeRetryDelay, RETRY_INTERVALS } from "./task-helpers.js";
-describe("sortByQuadrant", () => {
-    it("empty array returns empty array", () => {
-        assert.deepStrictEqual(sortByQuadrant([]), []);
-    });
-    it("does not modify the input array", () => {
-        const items = [
-            { quadrant: 3, id: "a" },
-            { quadrant: 1, id: "b" },
-        ];
-        const original = [...items];
-        sortByQuadrant(items);
-        assert.deepStrictEqual(items, original, "input array must not be mutated");
-    });
-    it("sorts ascending by quadrant", () => {
-        const items = [
-            { quadrant: 4, id: "d" },
-            { quadrant: 2, id: "b" },
-            { quadrant: 3, id: "c" },
-            { quadrant: 1, id: "a" },
-        ];
-        const result = sortByQuadrant(items);
-        assert.deepStrictEqual(result.map(i => i.quadrant), [1, 2, 3, 4]);
-    });
-    it("is stable: equal-quadrant items preserve original order", () => {
-        const items = [
-            { quadrant: 2, id: "first" },
-            { quadrant: 1, id: "solo" },
-            { quadrant: 2, id: "second" },
-        ];
-        const result = sortByQuadrant(items);
-        assert.strictEqual(result[0].id, "solo");
-        assert.strictEqual(result[1].id, "first", "first Q2 item should come before second Q2 item");
-        assert.strictEqual(result[2].id, "second");
-    });
-});
-describe("dedupeWorkItems", () => {
-    it("different type, same id are kept (not considered duplicates)", () => {
-        const items = [
-            { type: "order", id: "abc" },
-            { type: "user_task", id: "abc" },
-        ];
-        const result = dedupeWorkItems(items);
-        assert.strictEqual(result.length, 2, "order:abc and user_task:abc must both survive");
-    });
-    it("same type+id: only first occurrence is kept", () => {
-        const items = [
-            { type: "order", id: "x", extra: 1 },
-            { type: "order", id: "x", extra: 2 },
-        ];
-        const result = dedupeWorkItems(items);
-        assert.strictEqual(result.length, 1);
-        assert.strictEqual(result[0].extra, 1, "first occurrence must be preserved");
-    });
-    it("returns empty array for empty input", () => {
-        assert.deepStrictEqual(dedupeWorkItems([]), []);
-    });
-});
-describe("computeRetryDelay", () => {
-    it("count=0 returns 0 (immediate first retry)", () => {
-        assert.strictEqual(computeRetryDelay(0), 0);
-    });
-    it("count=1 returns 30_000", () => {
-        assert.strictEqual(computeRetryDelay(1), 30_000);
-    });
-    it("count=4 returns 7_200_000 (2h)", () => {
-        assert.strictEqual(computeRetryDelay(4), 2 * 3600_000);
-    });
-    it("count=5 returns null (exhausted)", () => {
-        assert.strictEqual(computeRetryDelay(5), null);
-    });
-    it("count=-1 returns null (negative treated as exhausted)", () => {
-        assert.strictEqual(computeRetryDelay(-1), null);
-    });
-    it("uses RETRY_INTERVALS as default intervals", () => {
-        for (let i = 0; i < RETRY_INTERVALS.length; i++) {
-            assert.strictEqual(computeRetryDelay(i), RETRY_INTERVALS[i]);
-        }
-    });
-    it("accepts a custom intervals array", () => {
-        const custom = [100, 200, 300];
-        assert.strictEqual(computeRetryDelay(0, custom), 100);
-        assert.strictEqual(computeRetryDelay(2, custom), 300);
-        assert.strictEqual(computeRetryDelay(3, custom), null);
-    });
-});