@fiale-plus/pi-rogue 0.2.0

package/node_modules/@fiale-plus/pi-rogue-context-broker/src/file.ts

@@ -0,0 +1,191 @@
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { safeName } from "@fiale-plus/pi-core";
+import type { BoundedContextBroker, ContextArtifact, ContextArtifactInput, ContextArtifactTier, ContextBrokerOptions, ContextBrokerStatus, ContextLookupQuery, ContextPurgeOptions } from "@fiale-plus/pi-core";
+import { createInMemoryContextBroker } from "./index.js";
+
+export interface FileContextBrokerOptions extends ContextBrokerOptions {
+  dir?: string;
+}
+
+const STORE_VERSION = 1;
+
+interface StoredRecord {
+  version: number;
+  handle: string;
+  baseTier?: ContextArtifactTier;
+  input: Omit<ContextArtifactInput, "payload"> & { payloadSha256: string };
+}
+
+function defaultStoreDir(): string {
+  return join(homedir(), ".pi", "agent", "fiale-plus", "context-broker");
+}
+
+function ensureDir(path: string): void {
+  mkdirSync(path, { recursive: true });
+}
+
+function metadataFile(dir: string): string {
+  return join(dir, "metadata.jsonl");
+}
+
+function blobFile(dir: string, sha256: string): string {
+  return join(dir, "blobs", `${sha256}.txt`);
+}
+
+function stableSource(input: ContextArtifactInput): string | undefined {
+  return input.parentIds?.find(Boolean);
+}
+
+function readStoredRecords(dir: string): StoredRecord[] {
+  const file = metadataFile(dir);
+  if (!existsSync(file)) return [];
+  const recordsByHandle = new Map<string, StoredRecord>();
+  for (const line of readFileSync(file, "utf8").split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = JSON.parse(trimmed) as StoredRecord;
+      if (parsed?.version === STORE_VERSION && parsed.handle && parsed.input?.payloadSha256) {
+        recordsByHandle.set(parsed.handle, parsed);
+      }
+    } catch {
+      // Ignore corrupt JSONL rows; durable storage is append-only recovery, not a startup blocker.
+    }
+  }
+  return [...recordsByHandle.values()];
+}
+
+function loadPayload(dir: string, sha256: string): string | undefined {
+  const file = blobFile(dir, sha256);
+  if (!existsSync(file)) return undefined;
+  return readFileSync(file, "utf8");
+}
+
+function artifactBaseTier(artifact: ContextArtifact, fallback?: ContextArtifactTier): ContextArtifactTier {
+  return (artifact as ContextArtifact & { baseTier?: ContextArtifactTier }).baseTier ?? fallback ?? artifact.tier;
+}
+
+function persistRecord(dir: string, artifact: ContextArtifact, input: ContextArtifactInput): void {
+  ensureDir(join(dir, "blobs"));
+  const blob = blobFile(dir, artifact.sha256);
+  if (!existsSync(blob)) writeFileSync(blob, artifact.payload, "utf8");
+  const record: StoredRecord = {
+    version: STORE_VERSION,
+    handle: artifact.handle,
+    baseTier: artifactBaseTier(artifact, input.tier),
+    input: {
+      sessionId: input.sessionId,
+      kind: input.kind,
+      summary: input.summary,
+      tags: input.tags,
+      paths: input.paths,
+      command: input.command,
+      branch: input.branch,
+      tier: artifactBaseTier(artifact, input.tier),
+      ttlMs: input.ttlMs,
+      pinned: artifact.pinned,
+      parentIds: input.parentIds,
+      createdAt: input.createdAt ?? artifact.createdAt,
+      payloadSha256: artifact.sha256,
+    },
+  };
+  ensureDir(dirname(metadataFile(dir)));
+  appendFileSync(metadataFile(dir), `${JSON.stringify(record)}\n`, "utf8");
+}
+
+function persistArtifactSnapshot(dir: string, artifact: ContextArtifact): void {
+  persistRecord(dir, artifact, {
+    sessionId: artifact.sessionId,
+    kind: artifact.kind,
+    payload: artifact.payload,
+    summary: artifact.summary,
+    tags: artifact.tags,
+    paths: artifact.paths,
+    command: artifact.command,
+    branch: artifact.branch,
+    tier: artifactBaseTier(artifact),
+    ttlMs: artifact.expiresAt ? Math.max(0, artifact.expiresAt - artifact.createdAt) : 0,
+    pinned: artifact.pinned,
+    parentIds: artifact.parentIds,
+    createdAt: artifact.createdAt,
+  });
+}
+
+function removeUnreferencedBlobs(dir: string, keptSha256: Set<string>): void {
+  const blobsDir = join(dir, "blobs");
+  if (!existsSync(blobsDir)) return;
+  for (const entry of readdirSync(blobsDir)) {
+    if (!entry.endsWith(".txt")) continue;
+    const sha256 = entry.slice(0, -4);
+    if (!keptSha256.has(sha256)) unlinkSync(join(blobsDir, entry));
+  }
+}
+
+export function createFileContextBroker(options: FileContextBrokerOptions = {}): BoundedContextBroker {
+  const dir = options.dir ?? process.env.PI_CONTEXT_BROKER_STORE_DIR ?? defaultStoreDir();
+  ensureDir(join(dir, "blobs"));
+  const broker = createInMemoryContextBroker(options);
+  const persistedSources = new Map<string, string>();
+  const handleAliases = new Map<string, string>();
+
+  for (const record of readStoredRecords(dir)) {
+    const payload = loadPayload(dir, record.input.payloadSha256);
+    if (payload === undefined) continue;
+    const artifact = broker.publish({ ...record.input, tier: record.baseTier ?? record.input.tier, payload });
+    handleAliases.set(record.handle, artifact.handle);
+    const source = stableSource(record.input as unknown as ContextArtifactInput);
+    if (source) persistedSources.set(source, artifact.handle);
+  }
+
+  function publish(input: ContextArtifactInput): ContextArtifact {
+    const source = stableSource(input);
+    const existingHandle = source ? persistedSources.get(source) : undefined;
+    if (existingHandle) {
+      const existing = broker.lookup({ handle: existingHandle })[0];
+      if (existing) return existing;
+    }
+
+    const artifact = broker.publish(input);
+    if (source) persistedSources.set(source, artifact.handle);
+    persistRecord(dir, artifact, input);
+    return artifact;
+  }
+
+  return {
+    publish,
+    lookup(query?: ContextLookupQuery): ContextArtifact[] {
+      const mappedHandle = query?.handle ? handleAliases.get(query.handle) : undefined;
+      return broker.lookup(mappedHandle ? { ...query, handle: mappedHandle } : query);
+    },
+    pin(idOrHandle: string, pinned?: boolean): ContextArtifact | null {
+      const artifact = broker.pin(handleAliases.get(idOrHandle) ?? idOrHandle, pinned);
+      if (artifact) persistArtifactSnapshot(dir, artifact);
+      return artifact;
+    },
+    prune(now?: number): ContextBrokerStatus { return broker.prune(now); },
+    purge(options?: ContextPurgeOptions): ContextBrokerStatus {
+      const status = broker.purge(options);
+      const remaining = broker.lookup({ limit: Number.MAX_SAFE_INTEGER });
+      persistedSources.clear();
+      handleAliases.clear();
+      writeFileSync(metadataFile(dir), "", "utf8");
+      const keptSha256 = new Set<string>();
+      for (const artifact of remaining) {
+        keptSha256.add(artifact.sha256);
+        for (const parentId of artifact.parentIds) persistedSources.set(parentId, artifact.handle);
+        handleAliases.set(artifact.handle, artifact.handle);
+        persistArtifactSnapshot(dir, artifact);
+      }
+      removeUnreferencedBlobs(dir, keptSha256);
+      return status;
+    },
+    status(): ContextBrokerStatus { return broker.status(); },
+    renderBrief(query?: ContextLookupQuery & { budgetBytes?: number }): string { return broker.renderBrief(query); },
+  };
+}
+
+export function contextBrokerStoreDirForSession(baseDir: string, sessionId: string): string {
+  return join(baseDir, safeName(sessionId));
+}

package/node_modules/@fiale-plus/pi-rogue-context-broker/src/index.test.ts

@@ -0,0 +1,302 @@
+import { createHash } from "node:crypto";
+import { describe, expect, it } from "vitest";
+import { createInMemoryContextBroker } from "./index.js";
+
+describe("createInMemoryContextBroker", () => {
+  it("publishes stable, unique handles and looks up artifacts by handle", () => {
+    const broker = createInMemoryContextBroker();
+    const first = broker.publish({
+      sessionId: "session-a",
+      kind: "tool_output",
+      payload: "same payload",
+      summary: "tests passed",
+      tags: ["test"],
+      paths: ["packages/core"],
+    });
+    const second = broker.publish({
+      sessionId: "session-a",
+      kind: "tool_output",
+      payload: "same payload",
+      summary: "same payload repeat",
+      tags: ["test"],
+      paths: ["packages/core"],
+    });
+
+    expect(first.handle).not.toEqual(second.handle);
+    expect(first.handle).toMatch(/^ctx:\/\/session\/session-a\/tool_output\//);
+    expect(broker.lookup({ handle: first.handle })).toEqual([first]);
+    expect(broker.lookup({ handle: second.handle })).toEqual([second]);
+  });
+
+  it("filters by session, kind, tag, path, and text", () => {
+    const broker = createInMemoryContextBroker();
+    const core = broker.publish({
+      sessionId: "s1",
+      kind: "tool_output",
+      payload: "vitest packages/core passed",
+      tags: ["test", "core"],
+      paths: ["packages/core/src/context-broker.ts"],
+    });
+    broker.publish({
+      sessionId: "s2",
+      kind: "advisor_brief",
+      payload: "different payload",
+      tags: ["advisor"],
+      paths: ["packages/advisor/src/router.ts"],
+    });
+
+    expect(broker.lookup({ sessionId: "s1", kind: "tool_output", tag: "core" })).toEqual([core]);
+    expect(broker.lookup({ path: "packages/core" })).toEqual([core]);
+    expect(broker.lookup({ text: "vitest" })).toEqual([core]);
+    expect(broker.lookup({ sessionId: "s2", kind: "tool_output" })).toEqual([]);
+  });
+
+  it("uses a metadata-only summary when callers omit summaries", () => {
+    const broker = createInMemoryContextBroker({ briefBytes: 500 });
+    const artifact = broker.publish({
+      sessionId: "s",
+      kind: "tool_output",
+      payload: "SECRET_TOKEN=abc123\n".repeat(20),
+      paths: ["logs/secret-output.txt"],
+    });
+
+    const brief = broker.renderBrief({ sessionId: "s" });
+
+    expect(artifact.summary).toContain("payload stored externally");
+    expect(artifact.summary).not.toContain("SECRET_TOKEN");
+    expect(brief).not.toContain("SECRET_TOKEN");
+    expect(brief).toContain(artifact.handle);
+  });
+
+  it("enforces record caps by pruning oldest unpinned artifacts", () => {
+    const broker = createInMemoryContextBroker({ maxRecords: 2, defaultTtlMs: 0 });
+    const first = broker.publish({ sessionId: "s", kind: "memory_note", payload: "one", createdAt: 1 });
+    const second = broker.publish({ sessionId: "s", kind: "memory_note", payload: "two", createdAt: 2 });
+    const third = broker.publish({ sessionId: "s", kind: "memory_note", payload: "three", createdAt: 3 });
+
+    expect(broker.lookup({ id: first.id })).toEqual([]);
+    expect(broker.lookup({ id: second.id })).toEqual([second]);
+    expect(broker.lookup({ id: third.id })).toEqual([third]);
+    expect(broker.status().records).toBe(2);
+  });
+
+  it("applies caps independently per session", () => {
+    const broker = createInMemoryContextBroker({ maxRecords: 1, defaultTtlMs: 0 });
+    const sessionOne = broker.publish({ sessionId: "s1", kind: "tool_output", payload: "one", createdAt: 1 });
+    const sessionTwo = broker.publish({ sessionId: "s2", kind: "tool_output", payload: "two", createdAt: 2 });
+
+    expect(broker.lookup({ sessionId: "s1" })).toEqual([sessionOne]);
+    expect(broker.lookup({ sessionId: "s2" })).toEqual([sessionTwo]);
+    expect(broker.status().records).toBe(2);
+  });
+
+  it("uses sequence tie-breakers when createdAt timestamps tie", () => {
+    const broker = createInMemoryContextBroker({ maxRecords: 2, defaultTtlMs: 0 });
+    const first = broker.publish({ sessionId: "s", kind: "tool_output", payload: "alpha", createdAt: 1000 });
+    const second = broker.publish({ sessionId: "s", kind: "tool_output", payload: "bravo", createdAt: 1000 });
+    const third = broker.publish({ sessionId: "s", kind: "tool_output", payload: "charlie", createdAt: 1000 });
+
+    expect(broker.lookup({ id: first.id })).toEqual([]);
+    expect(broker.lookup({ id: second.id })).toEqual([second]);
+    expect(broker.lookup({ id: third.id })).toEqual([third]);
+  });
+
+  it("enforces byte caps by pruning oldest unpinned artifacts", () => {
+    const broker = createInMemoryContextBroker({ maxBytes: 6, defaultTtlMs: 0 });
+    const first = broker.publish({ sessionId: "s", kind: "tool_output", payload: "12345", createdAt: 1 });
+    const second = broker.publish({ sessionId: "s", kind: "tool_output", payload: "abcde", createdAt: 2 });
+
+    expect(broker.lookup({ id: first.id })).toEqual([]);
+    expect(broker.lookup({ id: second.id })).toEqual([second]);
+    expect(broker.status().bytes).toBe(5);
+  });
+
+  it("preserves the returned handle when a new artifact exceeds maxBytes", () => {
+    const broker = createInMemoryContextBroker({ maxBytes: 4, defaultTtlMs: 0 });
+    const artifact = broker.publish({ sessionId: "s", kind: "tool_output", payload: "oversized", createdAt: 1 });
+
+    expect(broker.lookup({ id: artifact.id })).toEqual([artifact]);
+    expect(broker.lookup({ handle: artifact.handle })).toEqual([artifact]);
+    expect(broker.status().bytes).toBe(Buffer.byteLength("oversized", "utf8"));
+  });
+
+  it("computes bytes and SHA-256 on raw Buffer payload bytes", () => {
+    const broker = createInMemoryContextBroker({ maxBytes: 1024, defaultTtlMs: 0 });
+    const payload = Buffer.from([0x66, 0xff, 0x61, 0x62, 0x80, 0x00]);
+    const artifact = broker.publish({ sessionId: "s", kind: "tool_output", payload, createdAt: 1 });
+    const expectedSha = createHash("sha256").update(payload).digest("hex");
+
+    expect(artifact.bytes).toBe(payload.length);
+    expect(artifact.sha256).toBe(expectedSha);
+    expect(Buffer.byteLength(artifact.payload, "utf8")).toBeGreaterThan(artifact.bytes);
+  });
+
+  it("keeps pinned artifacts visible while pruning unpinned records", () => {
+    const broker = createInMemoryContextBroker({ maxRecords: 2, defaultTtlMs: 0 });
+    const pinned = broker.publish({ sessionId: "s", kind: "diff", payload: "important", pinned: true, createdAt: 1 });
+    const older = broker.publish({ sessionId: "s", kind: "diff", payload: "temporary", createdAt: 2 });
+    const newer = broker.publish({ sessionId: "s", kind: "diff", payload: "latest", createdAt: 3 });
+
+    expect(broker.lookup({ id: pinned.id })).toEqual([pinned]);
+    expect(broker.lookup({ id: older.id })).toEqual([]);
+    expect(broker.lookup({ id: newer.id })).toEqual([newer]);
+    expect(broker.status().pinnedRecords).toBe(1);
+  });
+
+  it("expires unpinned artifacts by ttl", () => {
+    const broker = createInMemoryContextBroker({ defaultTtlMs: 10 });
+    const artifact = broker.publish({ sessionId: "s", kind: "tool_output", payload: "old", createdAt: 100 });
+
+    broker.prune(111);
+
+    expect(broker.lookup({ id: artifact.id })).toEqual([]);
+  });
+
+  it("prunes expired artifacts before lookup without an explicit prune call", () => {
+    const broker = createInMemoryContextBroker({ defaultTtlMs: 1 });
+    const artifact = broker.publish({ sessionId: "s", kind: "tool_output", payload: "expired", createdAt: 1 });
+
+    expect(broker.lookup({ id: artifact.id })).toEqual([]);
+    expect(broker.status().records).toBe(0);
+  });
+
+  it("omits expired artifacts from rendered prompt briefs", () => {
+    const broker = createInMemoryContextBroker({ defaultTtlMs: 1, briefBytes: 500 });
+    const artifact = broker.publish({ sessionId: "s", kind: "tool_output", payload: "expired secret", summary: "expired summary", createdAt: 1 });
+
+    const brief = broker.renderBrief({ sessionId: "s" });
+
+    expect(brief).not.toContain(artifact.handle);
+    expect(brief).not.toContain("expired summary");
+  });
+
+  it("keeps pinned expired artifacts visible until unpinned", () => {
+    const broker = createInMemoryContextBroker({ defaultTtlMs: 1 });
+    const artifact = broker.publish({ sessionId: "s", kind: "tool_output", payload: "pinned", pinned: true, createdAt: 1 });
+
+    expect(broker.lookup({ id: artifact.id })).toEqual([artifact]);
+    expect(broker.pin(artifact.id, false)).toBeNull();
+    expect(broker.lookup({ id: artifact.id })).toEqual([]);
+  });
+
+  it("classifies artifacts into hot, warm, and cold tiers on publish", () => {
+    const broker = createInMemoryContextBroker({ defaultTtlMs: 0 });
+    const failure = broker.publish({ sessionId: "s", kind: "tool_output", payload: "failed", tags: ["error"], createdAt: 1 });
+    const command = broker.publish({ sessionId: "s", kind: "tool_output", payload: "passed", tags: ["ok"], createdAt: 2 });
+    const archive = broker.publish({ sessionId: "s", kind: "subagent_result", payload: "old", tags: ["completed"], createdAt: 3 });
+    const explicit = broker.publish({ sessionId: "s", kind: "diff", payload: "manual", tier: "cold", createdAt: 4 });
+
+    expect(failure.tier).toBe("hot");
+    expect(command.tier).toBe("warm");
+    expect(archive.tier).toBe("cold");
+    expect(explicit.tier).toBe("cold");
+    expect(broker.lookup({ sessionId: "s", tier: "cold" }).map((artifact) => artifact.id)).toEqual([explicit.id, archive.id]);
+  });
+
+  it("renders prompt briefs hot-first, warm-second, and excludes cold unless explicit", () => {
+    const broker = createInMemoryContextBroker({ briefBytes: 900, defaultTtlMs: 0 });
+    const cold = broker.publish({ sessionId: "s", kind: "tool_output", payload: "cold", summary: "cold archive", tier: "cold", createdAt: 1 });
+    const warm = broker.publish({ sessionId: "s", kind: "tool_output", payload: "warm", summary: "warm command", tier: "warm", createdAt: 2 });
+    const hot = broker.publish({ sessionId: "s", kind: "tool_output", payload: "hot", summary: "hot failure", tier: "hot", createdAt: 3 });
+
+    const brief = broker.renderBrief({ sessionId: "s" });
+    expect(brief).toContain("Hot:");
+    expect(brief).toContain(hot.handle);
+    expect(brief).toContain("Warm:");
+    expect(brief).toContain(warm.handle);
+    expect(brief).not.toContain(cold.handle);
+    expect(brief.indexOf(hot.handle)).toBeLessThan(brief.indexOf(warm.handle));
+
+    const coldBrief = broker.renderBrief({ sessionId: "s", tier: "cold", budgetBytes: 500 });
+    expect(coldBrief).toContain("Cold:");
+    expect(coldBrief).toContain(cold.handle);
+
+    expect(broker.pin(cold.handle, true)?.tier).toBe("hot");
+    expect(broker.renderBrief({ sessionId: "s" })).toContain(cold.handle);
+    expect(broker.pin(cold.handle, false)?.tier).toBe("cold");
+    expect(broker.renderBrief({ sessionId: "s" })).not.toContain(cold.handle);
+  });
+
+  it("applies tier-specific record, byte, and ttl retention", () => {
+    const broker = createInMemoryContextBroker({
+      defaultTtlMs: 0,
+      hotMaxRecords: 1,
+      warmMaxBytes: 6,
+      coldTtlMs: 10,
+    });
+    const oldHot = broker.publish({ sessionId: "s", kind: "tool_output", payload: "old-hot", tier: "hot", createdAt: 1 });
+    const newHot = broker.publish({ sessionId: "s", kind: "tool_output", payload: "new-hot", tier: "hot", createdAt: 2 });
+    const oldWarm = broker.publish({ sessionId: "s", kind: "tool_output", payload: "12345", tier: "warm", createdAt: 3 });
+    const newWarm = broker.publish({ sessionId: "s", kind: "tool_output", payload: "abcde", tier: "warm", createdAt: 4 });
+    const cold = broker.publish({ sessionId: "s", kind: "tool_output", payload: "cold", tier: "cold", createdAt: 5 });
+
+    expect(broker.lookup({ id: oldHot.id })).toEqual([]);
+    expect(broker.lookup({ id: newHot.id })).toEqual([newHot]);
+    expect(broker.lookup({ id: oldWarm.id })).toEqual([]);
+    expect(broker.lookup({ id: newWarm.id })).toEqual([newWarm]);
+
+    broker.prune(16);
+    expect(broker.lookup({ id: cold.id })).toEqual([]);
+  });
+
+  it("renders a bounded prompt brief with lookup instructions", () => {
+    const broker = createInMemoryContextBroker({ briefBytes: 180 });
+    broker.publish({
+      sessionId: "s",
+      kind: "tool_output",
+      payload: "x".repeat(500),
+      summary: "large command output passed with no failures",
+      tags: ["test"],
+      paths: ["packages/core"],
+    });
+
+    const brief = broker.renderBrief();
+
+    expect(Buffer.byteLength(brief, "utf8")).toBeLessThanOrEqual(180);
+    expect(brief).toContain("Context Broker");
+    expect(brief).toContain("ctx://session/s/tool_output/");
+  });
+
+  it("enforces prompt brief budgets by UTF-8 byte length", () => {
+    const broker = createInMemoryContextBroker({ briefBytes: 170 });
+    broker.publish({
+      sessionId: "emoji-session",
+      kind: "tool_output",
+      payload: "✅".repeat(200),
+      summary: "✅ 測試 passed ".repeat(20),
+      tags: ["測試", "✅"],
+      paths: ["packages/核心/✅.ts"],
+    });
+
+    const brief = broker.renderBrief({ budgetBytes: 170 });
+
+    expect(Buffer.byteLength(brief, "utf8")).toBeLessThanOrEqual(170);
+    expect(brief).toContain("Context Broker");
+  });
+
+  it("purges unpinned session artifacts while retaining pinned evidence", () => {
+    const broker = createInMemoryContextBroker();
+    const unpinned = broker.publish({ sessionId: "s", kind: "tool_output", payload: "scratch", summary: "scratch" });
+    const pinned = broker.publish({ sessionId: "s", kind: "tool_output", payload: "keep", summary: "keep", pinned: true });
+    const other = broker.publish({ sessionId: "other", kind: "tool_output", payload: "other", summary: "other" });
+
+    const status = broker.purge({ sessionId: "s", keepPinned: true });
+
+    expect(status.records).toBe(2);
+    expect(broker.lookup({ handle: unpinned.handle })).toEqual([]);
+    expect(broker.lookup({ handle: pinned.handle })[0]?.payload).toBe("keep");
+    expect(broker.lookup({ handle: other.handle })[0]?.payload).toBe("other");
+  });
+
+  it("enforces optional global caps across sessions", () => {
+    const broker = createInMemoryContextBroker({ maxRecords: 8, globalMaxRecords: 2 });
+    const first = broker.publish({ sessionId: "s1", kind: "tool_output", payload: "alpha", summary: "alpha" });
+    const second = broker.publish({ sessionId: "s2", kind: "tool_output", payload: "bravo", summary: "bravo" });
+    const pinned = broker.publish({ sessionId: "s3", kind: "tool_output", payload: "charlie", summary: "charlie", pinned: true });
+    broker.publish({ sessionId: "s1", kind: "tool_output", payload: "delta", summary: "delta" });
+
+    expect(broker.lookup({ handle: first.handle })).toEqual([]);
+    expect(broker.lookup({ handle: second.handle })).toEqual([]);
+    expect(broker.lookup({ handle: pinned.handle })[0]?.payload).toBe("charlie");
+  });
+});