muonroi-cli 1.8.1 → 1.8.4

package/dist/src/orchestrator/scope-ceiling.test.js

@@ -1,181 +0,0 @@
-/**
- * Tests for scope-ceiling module (Plan 04-4B).
- *
- * Covers:
- *  - Matrix lookup for every task_type × size cell (all 7 task_type rows
- *    referenced verbatim per locked CONTEXT)
- *  - Unknown taskType fallback to "general" row
- *  - parseBudgetOverride flag extraction + prompt cleaning
- *  - Session counter persistence + per-session isolation
- *  - Soft-warn step computation
- *  - forcedFinalize delegates to passed-in model factory (no hardcoded IDs)
- */
-import { afterEach, describe, expect, it } from "vitest";
-import { forcedFinalize, getSessionLastTask, getSessionStepCount, incSessionStep, parseBudgetOverride, recordSessionLastTask, resetSessionStep, resolveCeiling, softWarnStep, } from "./scope-ceiling.js";
-describe("resolveCeiling — matrix lookup (locked verbatim)", () => {
-    it("analyze row", () => {
-        expect(resolveCeiling("analyze", "small")).toBe(5);
-        expect(resolveCeiling("analyze", "medium")).toBe(10);
-        expect(resolveCeiling("analyze", "large")).toBe(15);
-    });
-    it("debug row", () => {
-        expect(resolveCeiling("debug", "small")).toBe(6);
-        expect(resolveCeiling("debug", "medium")).toBe(12);
-        expect(resolveCeiling("debug", "large")).toBe(20);
-    });
-    it("refactor row", () => {
-        expect(resolveCeiling("refactor", "small")).toBe(8);
-        expect(resolveCeiling("refactor", "medium")).toBe(14);
-        expect(resolveCeiling("refactor", "large")).toBe(22);
-    });
-    it("generate row", () => {
-        expect(resolveCeiling("generate", "small")).toBe(10);
-        expect(resolveCeiling("generate", "medium")).toBe(18);
-        expect(resolveCeiling("generate", "large")).toBe(30);
-    });
-    it("plan row", () => {
-        expect(resolveCeiling("plan", "small")).toBe(4);
-        expect(resolveCeiling("plan", "medium")).toBe(8);
-        expect(resolveCeiling("plan", "large")).toBe(12);
-    });
-    it("documentation row", () => {
-        expect(resolveCeiling("documentation", "small")).toBe(5);
-        expect(resolveCeiling("documentation", "medium")).toBe(8);
-        expect(resolveCeiling("documentation", "large")).toBe(12);
-    });
-    it("general row", () => {
-        expect(resolveCeiling("general", "small")).toBe(5);
-        expect(resolveCeiling("general", "medium")).toBe(10);
-        expect(resolveCeiling("general", "large")).toBe(20);
-    });
-    it("unknown taskType falls back to general row", () => {
-        expect(resolveCeiling("unknown-task", "small")).toBe(5);
-        expect(resolveCeiling("unknown-task", "medium")).toBe(10);
-        expect(resolveCeiling("unknown-task", "large")).toBe(20);
-    });
-    it("null/undefined taskType falls back to general", () => {
-        expect(resolveCeiling(undefined, "medium")).toBe(10);
-        expect(resolveCeiling(null, "large")).toBe(20);
-    });
-});
-describe("softWarnStep — floor(ceiling × 0.7)", () => {
-    it("computes 70% floor", () => {
-        expect(softWarnStep(10)).toBe(7);
-        expect(softWarnStep(20)).toBe(14);
-        expect(softWarnStep(5)).toBe(3); // floor(3.5)
-        expect(softWarnStep(8)).toBe(5); // floor(5.6)
-    });
-});
-describe("parseBudgetOverride", () => {
-    it("extracts numeric override + strips flag from prompt", () => {
-        const r = parseBudgetOverride("--budget-rounds 20 fix bug");
-        expect(r.override).toBe(20);
-        expect(r.cleanedPrompt).toBe("fix bug");
-    });
-    it("handles flag in middle of prompt", () => {
-        const r = parseBudgetOverride("fix --budget-rounds 50 the bug");
-        expect(r.override).toBe(50);
-        expect(r.cleanedPrompt).toBe("fix the bug");
-    });
-    it("returns undefined override when flag absent", () => {
-        const r = parseBudgetOverride("no flag here");
-        expect(r.override).toBeUndefined();
-        expect(r.cleanedPrompt).toBe("no flag here");
-    });
-    it("preserves empty prompt when flag is whole input", () => {
-        const r = parseBudgetOverride("--budget-rounds 7");
-        expect(r.override).toBe(7);
-        expect(r.cleanedPrompt).toBe("");
-    });
-    it("trims surrounding whitespace after strip", () => {
-        const r = parseBudgetOverride("   --budget-rounds 3   do thing   ");
-        expect(r.override).toBe(3);
-        expect(r.cleanedPrompt).toBe("do thing");
-    });
-    it("ignores malformed (non-numeric) value", () => {
-        const r = parseBudgetOverride("--budget-rounds abc do thing");
-        expect(r.override).toBeUndefined();
-        expect(r.cleanedPrompt).toBe("--budget-rounds abc do thing");
-    });
-});
-describe("session counter", () => {
-    afterEach(() => {
-        resetSessionStep("sess-A");
-        resetSessionStep("sess-B");
-    });
-    it("increment + read across two calls preserves count", () => {
-        expect(getSessionStepCount("sess-A")).toBe(0);
-        expect(incSessionStep("sess-A")).toBe(1);
-        expect(incSessionStep("sess-A")).toBe(2);
-        expect(getSessionStepCount("sess-A")).toBe(2);
-    });
-    it("different sessionId is isolated", () => {
-        incSessionStep("sess-A");
-        incSessionStep("sess-A");
-        incSessionStep("sess-A");
-        expect(getSessionStepCount("sess-A")).toBe(3);
-        expect(getSessionStepCount("sess-B")).toBe(0);
-        expect(incSessionStep("sess-B")).toBe(1);
-        expect(getSessionStepCount("sess-A")).toBe(3);
-    });
-    it("reset clears the counter", () => {
-        incSessionStep("sess-A");
-        incSessionStep("sess-A");
-        resetSessionStep("sess-A");
-        expect(getSessionStepCount("sess-A")).toBe(0);
-    });
-});
-describe("forcedFinalize", () => {
-    it("delegates to passed-in model — no hardcoded model id", async () => {
-        // Mock model factory that returns canned text. The shape mirrors what the
-        // AI SDK streamText would expose; forcedFinalize unwraps `.text` (or the
-        // async equivalent) and returns { text }.
-        const mockModel = {
-            __isMock: true,
-            // Marker so the implementation can detect this is a mock and short-circuit.
-        };
-        const result = await forcedFinalize({
-            model: mockModel,
-            messages: [{ role: "user", content: "hello" }],
-            system: "be brief",
-            // Test-only injection — production callers pass `model` only.
-            __testInvoke: async () => ({ text: "[forced-finalize] partial answer" }),
-        });
-        expect(result.text).toContain("forced-finalize");
-    });
-});
-describe("Phase 5 — session last-task tracking (Fix 2)", () => {
-    afterEach(() => {
-        const host = globalThis;
-        host.__muonroiSessionLastTask?.clear();
-    });
-    it("records and reads the last non-chitchat task row", () => {
-        recordSessionLastTask("sess-X", "generate", "medium");
-        expect(getSessionLastTask("sess-X")).toEqual({ taskType: "generate", size: "medium" });
-    });
-    it("returns null when no task has been recorded", () => {
-        expect(getSessionLastTask("sess-empty")).toBeNull();
-    });
-    it("ignores chitchat / general / empty taskType writes", () => {
-        recordSessionLastTask("sess-Y", "general", "small");
-        expect(getSessionLastTask("sess-Y")).toBeNull();
-        recordSessionLastTask("sess-Y", "", "small");
-        expect(getSessionLastTask("sess-Y")).toBeNull();
-    });
-    it("isolates sessions from each other", () => {
-        recordSessionLastTask("sess-A", "refactor", "large");
-        recordSessionLastTask("sess-B", "debug", "small");
-        expect(getSessionLastTask("sess-A")).toEqual({ taskType: "refactor", size: "large" });
-        expect(getSessionLastTask("sess-B")).toEqual({ taskType: "debug", size: "small" });
-    });
-    it("overwrites prior row on subsequent task turns within the same session", () => {
-        recordSessionLastTask("sess-C", "analyze", "small");
-        recordSessionLastTask("sess-C", "refactor", "medium");
-        expect(getSessionLastTask("sess-C")).toEqual({ taskType: "refactor", size: "medium" });
-    });
-    it("rejects empty sessionId", () => {
-        recordSessionLastTask("", "generate", "medium");
-        expect(getSessionLastTask("")).toBeNull();
-    });
-});
-//# sourceMappingURL=scope-ceiling.test.js.map

package/dist/src/orchestrator/scope-reminder.test.d.ts

@@ -1,15 +0,0 @@
-/**
- * src/orchestrator/scope-reminder.test.ts
- *
- * Phase 04 / Plan 4A — REQ-005 scope reminder cadence + format + soft-warn.
- *
- * Locked behaviour per 04-CONTEXT.md (Scope reminder 4A):
- *   - Cadence K: 3 small / 5 medium / 8 large; hard floor K >= 3
- *   - Format (<=200 chars):
- *       [scope-check step N/CEILING — task=TASKTYPE size=SIZE]
- *       original: "PROMPT_SNIPPET (first 100 chars)"
- *       still on scope? if no → emit final answer; if yes → continue.
- *   - Soft-warn fires ONCE per session at step === floor(ceiling * 0.7)
- *   - Reminder lives in tool_result/system message — never in system prompt
- */
-export {};

package/dist/src/orchestrator/scope-reminder.test.js

@@ -1,225 +0,0 @@
-/**
- * src/orchestrator/scope-reminder.test.ts
- *
- * Phase 04 / Plan 4A — REQ-005 scope reminder cadence + format + soft-warn.
- *
- * Locked behaviour per 04-CONTEXT.md (Scope reminder 4A):
- *   - Cadence K: 3 small / 5 medium / 8 large; hard floor K >= 3
- *   - Format (<=200 chars):
- *       [scope-check step N/CEILING — task=TASKTYPE size=SIZE]
- *       original: "PROMPT_SNIPPET (first 100 chars)"
- *       still on scope? if no → emit final answer; if yes → continue.
- *   - Soft-warn fires ONCE per session at step === floor(ceiling * 0.7)
- *   - Reminder lives in tool_result/system message — never in system prompt
- */
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { attachReminderToMessages, buildScopeReminder, cadenceForSize, shouldInjectCeilingCrossing, shouldInjectReminder, shouldInjectSoftWarn, shouldPreWarnCompaction, } from "./scope-reminder.js";
-describe("cadenceForSize", () => {
-    it("locks 3/5/8 for small/medium/large with hard floor >= 3", () => {
-        expect(cadenceForSize("small")).toBe(3);
-        expect(cadenceForSize("medium")).toBe(5);
-        expect(cadenceForSize("large")).toBe(8);
-    });
-    it("defends the K >= 3 hard floor against unknown sizes", () => {
-        // Cast through unknown — the public contract is "small"|"medium"|"large"
-        // but a caller can still pass garbage at runtime. Floor must hold.
-        expect(cadenceForSize("tiny")).toBeGreaterThanOrEqual(3);
-    });
-});
-describe("shouldInjectReminder", () => {
-    it("returns true at every multiple of K, false elsewhere", () => {
-        expect(shouldInjectReminder(0, 3)).toBe(false); // step 0 is pre-loop
-        expect(shouldInjectReminder(1, 3)).toBe(false);
-        expect(shouldInjectReminder(2, 3)).toBe(false);
-        expect(shouldInjectReminder(3, 3)).toBe(true);
-        expect(shouldInjectReminder(4, 3)).toBe(false);
-        expect(shouldInjectReminder(5, 3)).toBe(false);
-        expect(shouldInjectReminder(6, 3)).toBe(true);
-        expect(shouldInjectReminder(9, 3)).toBe(true);
-    });
-    it("works for K=5 (medium) and K=8 (large)", () => {
-        expect(shouldInjectReminder(5, 5)).toBe(true);
-        expect(shouldInjectReminder(10, 5)).toBe(true);
-        expect(shouldInjectReminder(7, 5)).toBe(false);
-        expect(shouldInjectReminder(8, 8)).toBe(true);
-        expect(shouldInjectReminder(16, 8)).toBe(true);
-        expect(shouldInjectReminder(9, 8)).toBe(false);
-    });
-    it("never fires for non-positive step", () => {
-        expect(shouldInjectReminder(-1, 3)).toBe(false);
-        expect(shouldInjectReminder(0, 3)).toBe(false);
-    });
-});
-describe("shouldInjectSoftWarn", () => {
-    beforeEach(() => {
-        // Reset global one-shot guard between tests.
-        globalThis.__muonroiSoftWarnFired = undefined;
-    });
-    afterEach(() => {
-        globalThis.__muonroiSoftWarnFired = undefined;
-    });
-    it("fires once at floor(ceiling * 0.7) per session", () => {
-        // ceiling 10 -> floor(7) = 7
-        expect(shouldInjectSoftWarn(6, 10, "sess-A")).toBe(false);
-        expect(shouldInjectSoftWarn(7, 10, "sess-A")).toBe(true);
-        // Subsequent calls within same session return false.
-        expect(shouldInjectSoftWarn(7, 10, "sess-A")).toBe(false);
-        expect(shouldInjectSoftWarn(8, 10, "sess-A")).toBe(false);
-    });
-    it("fires independently per session id", () => {
-        expect(shouldInjectSoftWarn(7, 10, "sess-A")).toBe(true);
-        // Different session — fresh one-shot.
-        expect(shouldInjectSoftWarn(7, 10, "sess-B")).toBe(true);
-        expect(shouldInjectSoftWarn(7, 10, "sess-B")).toBe(false);
-    });
-    it("does not fire below threshold", () => {
-        // ceiling 20 -> floor(14)
-        expect(shouldInjectSoftWarn(13, 20, "s1")).toBe(false);
-        expect(shouldInjectSoftWarn(14, 20, "s1")).toBe(true);
-    });
-});
-describe("shouldInjectCeilingCrossing", () => {
-    beforeEach(() => {
-        globalThis.__muonroiCeilingCrossingFired = undefined;
-    });
-    afterEach(() => {
-        globalThis.__muonroiCeilingCrossingFired = undefined;
-    });
-    it("fires exactly once per session at the first step past the natural ceiling", () => {
-        expect(shouldInjectCeilingCrossing(6, 6, "s1")).toBe(false); // equal, not past
-        expect(shouldInjectCeilingCrossing(7, 6, "s1")).toBe(true); // first crossing
-        expect(shouldInjectCeilingCrossing(8, 6, "s1")).toBe(false); // already fired
-        expect(shouldInjectCeilingCrossing(77, 6, "s1")).toBe(false); // still suppressed
-    });
-    it("fires independently per session", () => {
-        expect(shouldInjectCeilingCrossing(7, 6, "a")).toBe(true);
-        expect(shouldInjectCeilingCrossing(7, 6, "b")).toBe(true);
-        expect(shouldInjectCeilingCrossing(8, 6, "b")).toBe(false);
-    });
-    it("never fires below or at the ceiling", () => {
-        expect(shouldInjectCeilingCrossing(1, 6, "x")).toBe(false);
-        expect(shouldInjectCeilingCrossing(6, 6, "x")).toBe(false);
-    });
-    it("rejects non-positive or non-finite inputs", () => {
-        expect(shouldInjectCeilingCrossing(0, 6, "x")).toBe(false);
-        expect(shouldInjectCeilingCrossing(-1, 6, "x")).toBe(false);
-        expect(shouldInjectCeilingCrossing(7, 0, "x")).toBe(false);
-        expect(shouldInjectCeilingCrossing(Number.NaN, 6, "x")).toBe(false);
-    });
-});
-describe("buildScopeReminder", () => {
-    it("contains verbatim first 100 chars of prompt and stays <= 200 chars", () => {
-        const prompt = "A".repeat(200);
-        const out = buildScopeReminder({
-            step: 3,
-            ceiling: 10,
-            taskType: "refactor",
-            size: "small",
-            originalPrompt: prompt,
-        });
-        expect(out.length).toBeLessThanOrEqual(200);
-        // First 100 chars of prompt must appear verbatim.
-        expect(out).toContain("A".repeat(100));
-        // Header marker present (4V harness asserts this exact prefix).
-        expect(out).toMatch(/\[scope-check step 3\//);
-        expect(out).toContain("still on scope?");
-    });
-    it("uses whole prompt when shorter than 100 chars (no padding)", () => {
-        const out = buildScopeReminder({
-            step: 5,
-            ceiling: 14,
-            taskType: "debug",
-            size: "medium",
-            originalPrompt: "short prompt",
-        });
-        expect(out).toContain('"short prompt"');
-        expect(out.length).toBeLessThanOrEqual(200);
-    });
-    it("escapes embedded quote characters in the snippet", () => {
-        const out = buildScopeReminder({
-            step: 3,
-            ceiling: 10,
-            taskType: "generate",
-            size: "small",
-            originalPrompt: 'fix bug with "quoted" word',
-        });
-        // Embedded quote must be escaped to keep the snippet parseable.
-        expect(out).toMatch(/\\"quoted\\"/);
-        expect(out.length).toBeLessThanOrEqual(200);
-    });
-    it("hard-truncates final string to 200 chars defensively", () => {
-        // Even with monster taskType / size labels, hard cap holds.
-        const out = buildScopeReminder({
-            step: 9999,
-            ceiling: 99999,
-            taskType: "x".repeat(50),
-            size: "y".repeat(50),
-            originalPrompt: "P".repeat(500),
-        });
-        expect(out.length).toBeLessThanOrEqual(200);
-    });
-});
-describe("attachReminderToMessages", () => {
-    it("appends reminder text to the last tool message", () => {
-        const messages = [
-            { role: "user", content: "do the thing" },
-            {
-                role: "tool",
-                content: [
-                    {
-                        type: "tool-result",
-                        toolCallId: "id1",
-                        toolName: "read_file",
-                        output: { type: "text", value: "file contents" },
-                    },
-                ],
-            },
-        ];
-        const out = attachReminderToMessages(messages, "[scope-check step 3/10] etc");
-        expect(out.length).toBe(2);
-        const last = out[1];
-        expect(last.role).toBe("tool");
-        // Reminder text appears appended either as a new tool-result text
-        // value, or as a wrapper around the existing one. The contract is:
-        // the reminder string is now present in the JSON-stringified last msg.
-        expect(JSON.stringify(last)).toContain("[scope-check step 3/10] etc");
-    });
-    it("appends a system message when last message is text-only assistant", () => {
-        const messages = [
-            { role: "user", content: "hi" },
-            { role: "assistant", content: "ok" },
-        ];
-        const out = attachReminderToMessages(messages, "remind");
-        expect(out.length).toBe(3);
-        const tail = out[2];
-        expect(tail.role).toBe("system");
-        expect(tail.content).toBe("remind");
-    });
-    it("returns input unchanged when reminder is empty", () => {
-        const messages = [{ role: "user", content: "hi" }];
-        const out = attachReminderToMessages(messages, "");
-        expect(out).toEqual(messages);
-    });
-});
-describe("shouldPreWarnCompaction (regression: session 2b7a10219499 dead pre-warning)", () => {
-    const THRESHOLD = 200_000; // MUONROI_TOP_LEVEL_COMPACT_THRESHOLD_CHARS default
-    it("fires when prompt chars reach >=78% of the threshold (approaching compaction)", () => {
-        expect(shouldPreWarnCompaction(Math.floor(THRESHOLD * 0.78), THRESHOLD)).toBe(true);
-        expect(shouldPreWarnCompaction(190_000, THRESHOLD)).toBe(true);
-    });
-    it("does NOT fire while comfortably below the threshold", () => {
-        expect(shouldPreWarnCompaction(100_000, THRESHOLD)).toBe(false);
-        expect(shouldPreWarnCompaction(0, THRESHOLD)).toBe(false);
-    });
-    it("guards against the original bug: a message COUNT can never trip a char threshold", () => {
-        // The dead wiring compared stripped.length (a message count, ~tens) to the
-        // char-scaled threshold. With chars it crosses; with a count it never does.
-        const messageCount = 60; // plausible long-session message count
-        expect(shouldPreWarnCompaction(messageCount, THRESHOLD)).toBe(false);
-        expect(shouldPreWarnCompaction(170_000, THRESHOLD)).toBe(true);
-    });
-    it("is inert for a zero/negative threshold (no compaction configured)", () => {
-        expect(shouldPreWarnCompaction(999_999, 0)).toBe(false);
-    });
-});
-//# sourceMappingURL=scope-reminder.test.js.map

package/dist/src/orchestrator/session-experience.test.d.ts

@@ -1,6 +0,0 @@
-/**
- * session-experience — in-process record of the agent's lived session, so a
- * "cảm nhận trong CLI" / "are you blind?" question is answered from data, not by
- * re-reading source. Also the "measure before re-architecting" instrumentation.
- */
-export {};

package/dist/src/orchestrator/session-experience.test.js

@@ -1,72 +0,0 @@
-/**
- * session-experience — in-process record of the agent's lived session, so a
- * "cảm nhận trong CLI" / "are you blind?" question is answered from data, not by
- * re-reading source. Also the "measure before re-architecting" instrumentation.
- */
-import { afterEach, describe, expect, it } from "vitest";
-import { __resetSessionExperienceForTests, formatElisionManifest, formatSessionExperience, getSessionExperience, isSessionExperienceEmpty, recentElisions, recordCompaction, recordEeEvent, recordElision, recordRehydration, } from "./session-experience.js";
-describe("session-experience tracker", () => {
-    afterEach(() => __resetSessionExperienceForTests());
-    it("starts empty and reports an intact-context felt summary", () => {
-        expect(isSessionExperienceEmpty()).toBe(true);
-        const text = formatSessionExperience();
-        expect(text).toContain("Nothing notable");
-        expect(text).toContain("context is intact this session");
-        // Steering line must always tell the agent to use lived data, not source.
-        expect(text).toMatch(/not by reading the CLI source/i);
-    });
-    it("accumulates compaction, elision, rehydration and EE counters", () => {
-        recordCompaction(4);
-        recordCompaction(9);
-        recordElision("call_a", "read_file", 4100, 4);
-        recordElision("call_b", "grep", 2300, 9);
-        recordRehydration("cache");
-        recordRehydration("unavailable");
-        recordEeEvent("timeout");
-        const s = getSessionExperience();
-        expect(s.compactions).toBe(2);
-        expect(s.lastCompactionStep).toBe(9);
-        expect(s.elisions).toHaveLength(2);
-        expect(s.totalElidedChars).toBe(6400);
-        expect(s.rehydrations.cache).toBe(1);
-        expect(s.rehydrations.unavailable).toBe(1);
-        expect(s.eeTimeouts).toBe(1);
-        expect(isSessionExperienceEmpty()).toBe(false);
-    });
-    it("felt summary reflects real counters when non-empty", () => {
-        recordCompaction(3);
-        recordElision("call_x", "read_file", 5000, 3);
-        recordRehydration("ee");
-        const text = formatSessionExperience();
-        expect(text).toContain("fired 1x");
-        expect(text).toContain("last at step 3");
-        expect(text).toContain("Tool outputs elided: 1");
-        expect(text).toContain("ee=1");
-        expect(text).not.toContain("Nothing notable");
-    });
-    it("recentElisions returns newest first and respects the cap arg", () => {
-        for (let i = 0; i < 6; i++)
-            recordElision(`call_${i}`, "read_file", 1000 + i, i);
-        const recent = recentElisions(3);
-        expect(recent.map((e) => e.toolCallId)).toEqual(["call_5", "call_4", "call_3"]);
-    });
-    it("formatElisionManifest is empty with no elisions, actionable otherwise", () => {
-        expect(formatElisionManifest()).toBe("");
-        recordElision("0123456789abcdefXYZ", "read_file", 4096, 7);
-        const m = formatElisionManifest();
-        // id is shortened, tool + char count present, and points at ee_query.
-        expect(m).toContain("id=0123456789ab");
-        expect(m).toContain("read_file (4096c)");
-        expect(m).toMatch(/ee_query "tool-artifact id=XXX"/);
-    });
-    it("caps the elision log at 200 (FIFO) without unbounded growth", () => {
-        for (let i = 0; i < 250; i++)
-            recordElision(`c_${i}`, "bash", 500, i);
-        const s = getSessionExperience();
-        expect(s.elisions).toHaveLength(200);
-        // Oldest 50 dropped; newest retained.
-        expect(s.elisions[0].toolCallId).toBe("c_50");
-        expect(s.elisions.at(-1).toolCallId).toBe("c_249");
-    });
-});
-//# sourceMappingURL=session-experience.test.js.map

package/dist/src/orchestrator/stall-rescue.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/orchestrator/stall-rescue.test.js

@@ -1,117 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { attemptStallRescue, buildStallSynthesisMessages, detectReplyLanguageHint, pushStallToolResult, STALL_RESCUE_MAX_CHARS_PER_RESULT, STALL_RESCUE_MAX_RESULTS, } from "./stall-rescue.js";
-describe("pushStallToolResult", () => {
-    it("caps the buffer count, keeping the most recent results", () => {
-        const buf = [];
-        for (let i = 0; i < STALL_RESCUE_MAX_RESULTS + 5; i++)
-            pushStallToolResult(buf, "bash", `out-${i}`);
-        expect(buf.length).toBe(STALL_RESCUE_MAX_RESULTS);
-        // oldest dropped, newest kept
-        expect(buf[buf.length - 1]?.text).toBe(`out-${STALL_RESCUE_MAX_RESULTS + 4}`);
-        expect(buf.some((r) => r.text === "out-0")).toBe(false);
-    });
-    it("truncates per-entry text and defaults a missing tool name", () => {
-        const buf = [];
-        pushStallToolResult(buf, "", "x".repeat(STALL_RESCUE_MAX_CHARS_PER_RESULT + 500));
-        expect(buf[0]?.tool).toBe("tool");
-        expect(buf[0]?.text.length).toBe(STALL_RESCUE_MAX_CHARS_PER_RESULT);
-    });
-});
-describe("buildStallSynthesisMessages", () => {
-    it("appends one synthetic user turn with the request + tool digest", () => {
-        const base = [{ role: "user", content: "hi" }];
-        const out = buildStallSynthesisMessages(base, "find a bug", [
-            { tool: "grep", text: "match in a.ts" },
-            { tool: "read_file", text: "contents" },
-        ]);
-        expect(out.length).toBe(base.length + 1);
-        const last = out[out.length - 1];
-        expect(last.role).toBe("user");
-        expect(last.content).toContain("find a bug");
-        expect(last.content).toContain("grep");
-        expect(last.content).toContain("match in a.ts");
-        expect(last.content).toMatch(/Do NOT call any more tools/i);
-        // does not mutate the base array
-        expect(base.length).toBe(1);
-    });
-    it("prepends a Vietnamese reply directive when user wrote in Vietnamese", () => {
-        const out = buildStallSynthesisMessages([], "sửa thêm popup reload không xoá login", [
-            { tool: "grep", text: "found" },
-        ]);
-        const last = out[out.length - 1];
-        expect(last.content).toMatch(/^Reply in Vietnamese/);
-        expect(last.content).toContain("the user wrote in Vietnamese");
-    });
-    it("omits the language directive for plain English input", () => {
-        const out = buildStallSynthesisMessages([], "find a bug please", [{ tool: "grep", text: "found" }]);
-        const last = out[out.length - 1];
-        expect(last.content).not.toMatch(/^Reply in /);
-    });
-});
-describe("detectReplyLanguageHint", () => {
-    it("detects Vietnamese from any diacritic", () => {
-        expect(detectReplyLanguageHint("tìm")).toBe("Vietnamese");
-        expect(detectReplyLanguageHint("sửa thêm cho tôi")).toBe("Vietnamese");
-        expect(detectReplyLanguageHint("Cập nhật")).toBe("Vietnamese");
-    });
-    it("returns null for ASCII / English text", () => {
-        expect(detectReplyLanguageHint("commit and push please")).toBeNull();
-        expect(detectReplyLanguageHint("")).toBeNull();
-    });
-    it("returns null for a VN-only word with NO diacritics (the heuristic is conservative)", () => {
-        // 'commit push de auto ci/cd len prod nhe' — VN sans diacritics is indistinguishable
-        // from English under this heuristic. Acceptable: false negative, never false positive.
-        expect(detectReplyLanguageHint("commit push de auto ci/cd len prod nhe")).toBeNull();
-    });
-});
-describe("attemptStallRescue", () => {
-    it("returns null when there are no tool results (nothing to synthesize)", async () => {
-        let called = false;
-        const out = await attemptStallRescue({
-            baseMessages: [],
-            userText: "q",
-            toolResults: [],
-            finalize: async () => {
-                called = true;
-                return { text: "should not run" };
-            },
-        });
-        expect(out).toBeNull();
-        expect(called).toBe(false);
-    });
-    it("returns the synthesized text when finalize yields content", async () => {
-        const out = await attemptStallRescue({
-            baseMessages: [{ role: "user", content: "x" }],
-            userText: "find a bug",
-            toolResults: [{ tool: "grep", text: "found it in a.ts:42" }],
-            finalize: async ({ messages }) => {
-                // proves the digest reached the finalize call
-                const last = messages[messages.length - 1];
-                expect(last.content).toContain("a.ts:42");
-                return { text: "The bug is at a.ts:42 — null deref." };
-            },
-        });
-        expect(out).toBe("The bug is at a.ts:42 — null deref.");
-    });
-    it("returns null when finalize yields empty/whitespace text", async () => {
-        const out = await attemptStallRescue({
-            baseMessages: [],
-            userText: "q",
-            toolResults: [{ tool: "bash", text: "out" }],
-            finalize: async () => ({ text: "   " }),
-        });
-        expect(out).toBeNull();
-    });
-    it("never throws — returns null when finalize rejects (provider still dead)", async () => {
-        const out = await attemptStallRescue({
-            baseMessages: [],
-            userText: "q",
-            toolResults: [{ tool: "bash", text: "out" }],
-            finalize: async () => {
-                throw new Error("stall again");
-            },
-        });
-        expect(out).toBeNull();
-    });
-});
-//# sourceMappingURL=stall-rescue.test.js.map

package/dist/src/orchestrator/stall-watchdog.test.d.ts

@@ -1 +0,0 @@
-export {};