chore: consolidate test files into __tests__/ dirs and clean stray engine artifacts

- Move all co-located *.test.* files into sibling __tests__/ directories so the
  layout is consistent across packages (159 renames + content-rewrite moves).
  Updates relative imports, vi.mock specifiers, and __dirname/import.meta.url
  path resolutions where tests read fixtures from disk.
- Drop tracked tsc-emit alongside engine .ts sources (auth-storage/logger/
  skill-resolver/context-limit-detector/pi.{js,d.ts,*.map}). These were
  accidentally committed in a merge and the stale pi.js was masking a real
  test-mock vs source mismatch (tests imported "../pi.js" and vite preferred
  the stale build over pi.ts).
- Add packages/engine/.gitignore to block future src/*.{js,d.ts,map}.
- Refactor plugin pi-module seams (openclaw/paperclip/hermes) to ESM-import
  createFnAgent / promptWithFallback / describeModel from @fusion/engine
  instead of require()-ing packages/engine/src/pi.js. Adds @fusion/engine to
  the two plugin package.jsons that were missing it; exports describeModel
  from the engine public API.
- Fix engine test mocks now that they run against current pi.ts: add
  ModelRegistry.create static to mocks in pi.test.ts and pi-create-fn-agent
  .test.ts; switch three boundary-result toEqual assertions to toMatchObject
  so the new content/isError fields don't trip exact-match comparison.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

packages/engine/src/__tests__/token-cap-detector.test.ts

@@ -0,0 +1,174 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { TokenCapDetector, type TokenCapCheckResult } from "../token-cap-detector.js";
+
+/** Create a mock AgentSession with the given context usage. */
+function createMockSession(
+  contextUsage:
+    | { tokens: number | null; contextWindow: number; percent: number | null }
+    | undefined,
+) {
+  return {
+    getContextUsage: vi.fn(() => contextUsage),
+  };
+}
+
+describe("TokenCapDetector", () => {
+  let detector: TokenCapDetector;
+
+  beforeEach(() => {
+    detector = new TokenCapDetector();
+  });
+
+  it("does not compact when tokenCap is undefined", async () => {
+    const session = createMockSession({
+      tokens: 150000,
+      contextWindow: 200000,
+      percent: 75,
+    });
+    const compactFn = vi.fn();
+
+    const result = await detector.checkAndCompact(
+      session as any,
+      "FN-001",
+      undefined,
+      compactFn,
+    );
+
+    expect(result.triggered).toBe(false);
+    expect(result.message).toBe("token cap not configured");
+    expect(compactFn).not.toHaveBeenCalled();
+  });
+
+  it("does not compact when tokens < cap", async () => {
+    const session = createMockSession({
+      tokens: 100000,
+      contextWindow: 200000,
+      percent: 50,
+    });
+    const compactFn = vi.fn();
+
+    const result = await detector.checkAndCompact(
+      session as any,
+      "FN-001",
+      150000,
+      compactFn,
+    );
+
+    expect(result.triggered).toBe(false);
+    expect(result.message).toContain("100000");
+    expect(result.message).toContain("150000");
+    expect(compactFn).not.toHaveBeenCalled();
+  });
+
+  it("compacts when tokens == cap", async () => {
+    const session = createMockSession({
+      tokens: 100000,
+      contextWindow: 200000,
+      percent: 50,
+    });
+    const compactFn = vi.fn().mockResolvedValue({ tokensBefore: 100000 });
+
+    const result = await detector.checkAndCompact(
+      session as any,
+      "FN-001",
+      100000,
+      compactFn,
+    );
+
+    expect(result.triggered).toBe(true);
+    expect(result.tokensBefore).toBe(100000);
+    expect(compactFn).toHaveBeenCalledTimes(1);
+  });
+
+  it("compacts when tokens > cap", async () => {
+    const session = createMockSession({
+      tokens: 150000,
+      contextWindow: 200000,
+      percent: 75,
+    });
+    const compactFn = vi.fn().mockResolvedValue({ tokensBefore: 150000 });
+
+    const result = await detector.checkAndCompact(
+      session as any,
+      "FN-001",
+      100000,
+      compactFn,
+    );
+
+    expect(result.triggered).toBe(true);
+    expect(result.tokensBefore).toBe(150000);
+  });
+
+  it("handles undefined usage gracefully", async () => {
+    const session = createMockSession(undefined);
+    const compactFn = vi.fn();
+
+    const result = await detector.checkAndCompact(
+      session as any,
+      "FN-001",
+      100000,
+      compactFn,
+    );
+
+    expect(result.triggered).toBe(false);
+    expect(result.message).toBe("context usage unknown");
+    expect(compactFn).not.toHaveBeenCalled();
+  });
+
+  it("handles null tokens gracefully", async () => {
+    const session = createMockSession({
+      tokens: null,
+      contextWindow: 200000,
+      percent: null,
+    });
+    const compactFn = vi.fn();
+
+    const result = await detector.checkAndCompact(
+      session as any,
+      "FN-001",
+      100000,
+      compactFn,
+    );
+
+    expect(result.triggered).toBe(false);
+    expect(result.message).toBe("context usage unknown");
+  });
+
+  it("returns triggered=false when compact fails", async () => {
+    const session = createMockSession({
+      tokens: 150000,
+      contextWindow: 200000,
+      percent: 75,
+    });
+    const compactFn = vi.fn().mockResolvedValue(null);
+
+    const result = await detector.checkAndCompact(
+      session as any,
+      "FN-001",
+      100000,
+      compactFn,
+    );
+
+    expect(result.triggered).toBe(false);
+    expect(result.message).toBe("compaction failed or unavailable");
+  });
+
+  it("triggers immediately when tokenCap is 0 and tokens are positive", async () => {
+    const session = createMockSession({
+      tokens: 1,
+      contextWindow: 200000,
+      percent: 0,
+    });
+    const compactFn = vi.fn().mockResolvedValue({ tokensBefore: 1 });
+
+    const result = await detector.checkAndCompact(
+      session as any,
+      "FN-001",
+      0,
+      compactFn,
+    );
+
+    expect(result.triggered).toBe(true);
+    expect(result.tokensBefore).toBe(1);
+  });
+});