@tyvm/knowhow 0.0.159 → 0.0.160

package/tests/agents/tools/replyToParent.test.ts

@@ -1,125 +0,0 @@
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import { replyToParent } from "../../../src/agents/tools/replyToParent";
-
-/**
- * These tests exercise the `_ctx`-based self-referential mechanism:
- * replyToParent discovers who is calling (and which parent spawned them)
- * purely from the per-call context object threaded in as the last positional
- * argument by ToolsService.callTool.
- */
-describe("replyToParent (_ctx self-referential tool)", () => {
-  let tmpCwd: string;
-  let originalCwd: string;
-  let agentsDir: string;
-
-  beforeEach(() => {
-    originalCwd = process.cwd();
-    tmpCwd = fs.mkdtempSync(path.join(os.tmpdir(), "reply-parent-"));
-    process.chdir(tmpCwd);
-    agentsDir = path.join(tmpCwd, ".knowhow", "processes", "agents");
-    fs.mkdirSync(agentsDir, { recursive: true });
-  });
-
-  afterEach(() => {
-    process.chdir(originalCwd);
-    fs.rmSync(tmpCwd, { recursive: true, force: true });
-  });
-
-  function makeTask(taskId: string, meta: Record<string, any> = {}) {
-    const dir = path.join(agentsDir, taskId);
-    fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(path.join(dir, "input.txt"), "", "utf8");
-    fs.writeFileSync(
-      path.join(dir, "metadata.json"),
-      JSON.stringify({ taskId, ...meta }, null, 2),
-      "utf8"
-    );
-    return dir;
-  }
-
-  it("returns a helpful message when there is no parent", async () => {
-    makeTask("child-1"); // no parentTaskId
-    const result = await replyToParent("hi", { taskId: "child-1" });
-    expect(result).toMatch(/No parent task found/);
-  });
-
-  it("uses parentTaskId directly from _ctx when provided", async () => {
-    const parentDir = makeTask("parent-1");
-    makeTask("child-2", { parentTaskId: "parent-1" });
-
-    const result = await replyToParent("progress update", {
-      taskId: "child-2",
-      parentTaskId: "parent-1",
-    });
-
-    expect(result).toMatch(/Sent message to parent task parent-1/);
-    const parentInput = fs.readFileSync(
-      path.join(parentDir, "input.txt"),
-      "utf8"
-    );
-    expect(parentInput).toContain("progress update");
-    expect(parentInput).toContain("[from:child-2]");
-  });
-
-  it("falls back to reading parentTaskId from the caller's metadata.json", async () => {
-    const parentDir = makeTask("parent-2");
-    makeTask("child-3", { parentTaskId: "parent-2" });
-
-    // No parentTaskId in _ctx — must be discovered from child-3's metadata.
-    const result = await replyToParent("need help", { taskId: "child-3" });
-
-    expect(result).toMatch(/Sent message to parent task parent-2/);
-    const parentInput = fs.readFileSync(
-      path.join(parentDir, "input.txt"),
-      "utf8"
-    );
-    expect(parentInput).toContain("need help");
-  });
-
-  it("reads taskId/name off _ctx.caller when taskId not set directly", async () => {
-    const parentDir = makeTask("parent-3");
-    makeTask("child-4", { parentTaskId: "parent-3" });
-
-    const fakeAgent = { currentTaskId: "child-4", name: "Researcher" };
-    const result = await replyToParent("done researching", {
-      caller: fakeAgent,
-    });
-
-    expect(result).toMatch(/Sent message to parent task parent-3/);
-    const parentInput = fs.readFileSync(
-      path.join(parentDir, "input.txt"),
-      "utf8"
-    );
-    expect(parentInput).toContain("[agent:Researcher]");
-    expect(parentInput).toContain("done researching");
-  });
-
-  it("appends rather than clobbers existing parent input", async () => {
-    const parentDir = makeTask("parent-4");
-    fs.writeFileSync(
-      path.join(parentDir, "input.txt"),
-      "existing message\n",
-      "utf8"
-    );
-    makeTask("child-5", { parentTaskId: "parent-4" });
-
-    await replyToParent("second message", {
-      taskId: "child-5",
-      parentTaskId: "parent-4",
-    });
-
-    const parentInput = fs.readFileSync(
-      path.join(parentDir, "input.txt"),
-      "utf8"
-    );
-    expect(parentInput).toContain("existing message");
-    expect(parentInput).toContain("second message");
-  });
-
-  it("returns error for empty message", async () => {
-    const result = await replyToParent("   ", { taskId: "whatever" });
-    expect(result).toMatch(/No message provided/);
-  });
-});

package/tests/agents/tools/sendAgentMessage.test.ts

@@ -1,99 +0,0 @@
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import { sendAgentMessage } from "../../../src/agents/tools/sendAgentMessage";
-
-describe("sendAgentMessage", () => {
-  let tmpCwd: string;
-  let originalCwd: string;
-  let agentsDir: string;
-
-  beforeEach(() => {
-    originalCwd = process.cwd();
-    tmpCwd = fs.mkdtempSync(path.join(os.tmpdir(), "send-msg-"));
-    process.chdir(tmpCwd);
-    agentsDir = path.join(tmpCwd, ".knowhow", "processes", "agents");
-    fs.mkdirSync(agentsDir, { recursive: true });
-  });
-
-  afterEach(() => {
-    process.chdir(originalCwd);
-    fs.rmSync(tmpCwd, { recursive: true, force: true });
-  });
-
-  function makeTask(taskId: string): string {
-    const dir = path.join(agentsDir, taskId);
-    fs.mkdirSync(dir, { recursive: true });
-    return dir;
-  }
-
-  it("requires taskId and message", async () => {
-    expect(await sendAgentMessage({ taskId: "", message: "hi" })).toMatch(
-      /taskId is required/
-    );
-    expect(await sendAgentMessage({ taskId: "x", message: "" })).toMatch(
-      /message is required/
-    );
-  });
-
-  it("errors when the target task dir doesn't exist", async () => {
-    const res = await sendAgentMessage({ taskId: "nope", message: "hi" });
-    expect(res).toMatch(/target task directory not found/);
-  });
-
-  it("appends an envelope with sender identity from _ctx", async () => {
-    makeTask("child-1");
-    const res = await sendAgentMessage({
-      taskId: "child-1",
-      message: "do the thing",
-      _ctx: { taskId: "parent-1", caller: { name: "Developer" } },
-    });
-    expect(res).toMatch(/Sent message to task child-1/);
-    const input = fs.readFileSync(
-      path.join(agentsDir, "child-1", "input.txt"),
-      "utf8"
-    );
-    expect(input).toContain("[from:parent-1/Developer] do the thing");
-  });
-
-  it("uses explicit from when provided", async () => {
-    makeTask("child-2");
-    await sendAgentMessage({
-      taskId: "child-2",
-      message: "msg",
-      from: "orchestrator",
-    });
-    const input = fs.readFileSync(
-      path.join(agentsDir, "child-2", "input.txt"),
-      "utf8"
-    );
-    expect(input).toContain("[from:orchestrator] msg");
-  });
-
-  it("delivers as /poke when poke:true (interrupts recipient)", async () => {
-    makeTask("child-3");
-    await sendAgentMessage({
-      taskId: "child-3",
-      message: "stop and reconsider",
-      from: "boss",
-      poke: true,
-    });
-    const input = fs.readFileSync(
-      path.join(agentsDir, "child-3", "input.txt"),
-      "utf8"
-    );
-    expect(input).toMatch(/^\/poke \[from:boss\] stop and reconsider/);
-  });
-
-  it("appends without clobbering existing pending messages", async () => {
-    const dir = makeTask("child-4");
-    fs.writeFileSync(path.join(dir, "input.txt"), "existing line\n", "utf8");
-    await sendAgentMessage({
-      taskId: "child-4",
-      message: "second",
-      from: "a",
-    });
-    const input = fs.readFileSync(path.join(dir, "input.txt"), "utf8");
-    expect(input).toBe("existing line\n[from:a] second\n");
-  });
-});

package/tests/agents/tools/waitForAgentCompleted.test.ts

@@ -1,147 +0,0 @@
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import { waitForAgentCompleted } from "../../../src/agents/tools/waitForAgentCompleted";
-
-describe("waitForAgentCompleted", () => {
-  let tmpCwd: string;
-  let originalCwd: string;
-  let agentsDir: string;
-
-  beforeEach(() => {
-    originalCwd = process.cwd();
-    tmpCwd = fs.mkdtempSync(path.join(os.tmpdir(), "wait-agent-"));
-    process.chdir(tmpCwd);
-    agentsDir = path.join(tmpCwd, ".knowhow", "processes", "agents");
-    fs.mkdirSync(agentsDir, { recursive: true });
-  });
-
-  afterEach(() => {
-    process.chdir(originalCwd);
-    fs.rmSync(tmpCwd, { recursive: true, force: true });
-  });
-
-  function makeTask(taskId: string, meta: Record<string, any> = {}, status?: string) {
-    const dir = path.join(agentsDir, taskId);
-    fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(
-      path.join(dir, "metadata.json"),
-      JSON.stringify({ taskId, ...meta }, null, 2),
-      "utf8"
-    );
-    if (status !== undefined) {
-      fs.writeFileSync(path.join(dir, "status.txt"), status, "utf8");
-    }
-    return dir;
-  }
-
-  it("returns error when taskId missing", async () => {
-    const res = JSON.parse(await waitForAgentCompleted({ taskId: "" }));
-    expect(res.status).toBe("error");
-    expect(res.error).toMatch(/taskId is required/);
-  });
-
-  it("returns error when task directory does not exist", async () => {
-    const res = JSON.parse(await waitForAgentCompleted({ taskId: "nope" }));
-    expect(res.status).toBe("error");
-    expect(res.error).toMatch(/No agent task directory/);
-  });
-
-  it("returns immediately with structured result for a completed task", async () => {
-    makeTask("done-1", {
-      status: "completed",
-      totalCostUsd: 1.23,
-      result: "the final answer",
-      artifacts: ["a.txt"],
-    });
-
-    const res = JSON.parse(await waitForAgentCompleted({ taskId: "done-1" }));
-    expect(res.status).toBe("completed");
-    expect(res.costUsd).toBe(1.23);
-    expect(res.finalAnswer).toBe("the final answer");
-    expect(res.artifacts).toEqual(["a.txt"]);
-  });
-
-  it("falls back to last assistant message when no result field", async () => {
-    makeTask("done-2", {
-      status: "completed",
-      totalCostUsd: 0.5,
-      threads: [
-        [
-          { role: "user", content: "do it" },
-          { role: "assistant", content: "I did it" },
-        ],
-      ],
-    });
-
-    const res = JSON.parse(await waitForAgentCompleted({ taskId: "done-2" }));
-    expect(res.finalAnswer).toBe("I did it");
-  });
-
-  it("treats inProgress:false with no status as completed", async () => {
-    makeTask("done-3", { inProgress: false, totalCostUsd: 0.1, result: "ok" });
-    const res = JSON.parse(await waitForAgentCompleted({ taskId: "done-3" }));
-    expect(res.status).toBe("completed");
-  });
-
-  it("times out on a still-running task", async () => {
-    makeTask("running-1", { status: "running", totalCostUsd: 0.2 });
-    const res = JSON.parse(
-      await waitForAgentCompleted({
-        taskId: "running-1",
-        timeoutMs: 300,
-        pollIntervalMs: 100,
-      })
-    );
-    expect(res.timedOut).toBe(true);
-    expect(res.status).toBe("running");
-    expect(res.costUsd).toBe(0.2);
-  });
-
-  it("resolves when a running task transitions to completed mid-poll", async () => {
-    const dir = makeTask("running-2", { status: "running", totalCostUsd: 0 });
-
-    // Flip to completed shortly after we start waiting.
-    setTimeout(() => {
-      fs.writeFileSync(
-        path.join(dir, "metadata.json"),
-        JSON.stringify(
-          {
-            taskId: "running-2",
-            status: "completed",
-            totalCostUsd: 2.0,
-            result: "eventually done",
-          },
-          null,
-          2
-        ),
-        "utf8"
-      );
-    }, 150);
-
-    const res = JSON.parse(
-      await waitForAgentCompleted({
-        taskId: "running-2",
-        timeoutMs: 3000,
-        pollIntervalMs: 100,
-      })
-    );
-    expect(res.status).toBe("completed");
-    expect(res.finalAnswer).toBe("eventually done");
-    expect(res.costUsd).toBe(2.0);
-  });
-
-  it("fails a task whose pid is dead without a terminal status", async () => {
-    // Use a pid that is virtually guaranteed not to exist.
-    makeTask("crashed-1", { status: "running", totalCostUsd: 0.3, pid: 999999 });
-    const res = JSON.parse(
-      await waitForAgentCompleted({
-        taskId: "crashed-1",
-        timeoutMs: 5000,
-        pollIntervalMs: 100,
-      })
-    );
-    expect(res.status).toBe("failed");
-    expect(res.error).toMatch(/exited without writing a terminal status/);
-  });
-});

package/tests/chat/detach-attach-rendering.test.ts

@@ -1,315 +0,0 @@
-
-/**
- * Tests for detach / re-attach rendering correctness.
- *
- * Bug: after calling /detach and then /attach again, the agent's tool calls
- * and messages were not rendering to the console.
- *
- * Root cause: both SessionsModule.attachToFsAgent / attachToWebAgent AND
- * AgentModule.attachedAgentChatLoop were calling wireAgentRendering().
- * Since wireAgentRendering uses setListener (keyed, replaces-on-conflict),
- * the second call on the SAME EventService replaced the first — but the
- * watcher's `done` event handler registered by SessionsModule was also
- * removed. More critically: after /detach, unwireAgentRendering() removes
- * the keyed listeners from `_wireAgentEvents` and clears the stored ref.
- * On re-attach a new FsSyncedAgentWatcher is created with a fresh
- * EventService, but the double-wire means the stored `_wireAgentEvents`
- * ref held by the AgentModule was pointing at the WRONG EventService
- * (the one from the second wireAgentRendering call).
- *
- * The fix: SessionsModule no longer calls wireAgentRendering itself —
- * it delegates entirely to attachedAgentChatLoop which already calls it.
- *
- * These tests verify the wireAgentRendering / unwireAgentRendering contract
- * using real EventService instances so we catch regressions in EventService
- * changes too.
- */
-
-import { EventService } from "../../src/services/EventService";
-
-// ─── Minimal harness that mirrors AgentModule's wire/unwire logic exactly ────
-
-const EVENT_TYPES = {
-  done: "done",
-  toolCall: "tool:pre_call",
-  toolUsed: "tool:post_call",
-  agentSay: "agent:say",
-  threadUpdate: "thread_update",
-};
-
-interface RenderEvent {
-  type: string;
-  taskId: string;
-  agentName: string;
-  data: any;
-}
-
-class RenderingHarness {
-  // Mirror of AgentModule's stored wire params
-  private _wireAgentEvents: EventService | undefined;
-  private _wireTaskId: string | undefined;
-  private _wireAgentName: string | undefined;
-  private _wireEventTypes:
-    | { toolCall?: string; toolUsed?: string; agentSay?: string; done: string }
-    | undefined;
-
-  public rendered: RenderEvent[] = [];
-
-  /**
-   * Mirrors AgentModule.wireAgentRendering exactly (uses real EventService.setListener).
-   */
-  wireAgentRendering(
-    taskId: string,
-    agentEvents: EventService,
-    eventTypes: { toolCall?: string; toolUsed?: string; agentSay?: string; done: string },
-    agentName: string
-  ): void {
-    if (eventTypes.toolCall) {
-      agentEvents.setListener(
-        { key: "agentModule:render:toolCall", event: eventTypes.toolCall },
-        (data: any) => this.rendered.push({ type: "toolCall", taskId, agentName, data })
-      );
-    }
-    if (eventTypes.toolUsed) {
-      agentEvents.setListener(
-        { key: "agentModule:render:toolUsed", event: eventTypes.toolUsed },
-        (data: any) => this.rendered.push({ type: "toolResult", taskId, agentName, data })
-      );
-    }
-    if (eventTypes.agentSay) {
-      agentEvents.setListener(
-        { key: "agentModule:render:agentSay", event: eventTypes.agentSay },
-        (data: any) => this.rendered.push({ type: "agentMessage", taskId, agentName, data })
-      );
-    }
-    this._wireAgentEvents = agentEvents;
-    this._wireTaskId = taskId;
-    this._wireAgentName = agentName;
-    this._wireEventTypes = eventTypes;
-  }
-
-  /**
-   * Mirrors AgentModule.unwireAgentRendering exactly.
-   */
-  unwireAgentRendering(): void {
-    if (this._wireAgentEvents) {
-      this._wireAgentEvents.removeManagedListenersByPrefix("agentModule:render:");
-      this._wireAgentEvents = undefined;
-    }
-    this._wireTaskId = undefined;
-    this._wireAgentName = undefined;
-    this._wireEventTypes = undefined;
-  }
-
-  reset() {
-    this.rendered = [];
-  }
-}
-
-// ─── Tests ────────────────────────────────────────────────────────────────────
-
-describe("detach / re-attach rendering", () => {
-  let harness: RenderingHarness;
-
-  beforeEach(() => {
-    harness = new RenderingHarness();
-  });
-
-  // 1. Basic: emitted events reach the renderer after wireAgentRendering ────────
-
-  it("emitted events reach the renderer after wireAgentRendering", () => {
-    const events = new EventService();
-    harness.wireAgentRendering("task-1", events, EVENT_TYPES, "Dev");
-
-    events.emit(EVENT_TYPES.toolCall, { toolCall: { function: { name: "execCommand" } } });
-    events.emit(EVENT_TYPES.agentSay, { message: "hello" });
-    events.emit(EVENT_TYPES.toolUsed, { toolCall: {}, functionResp: "output" });
-
-    expect(harness.rendered).toHaveLength(3);
-    expect(harness.rendered[0].type).toBe("toolCall");
-    expect(harness.rendered[1].type).toBe("agentMessage");
-    expect(harness.rendered[2].type).toBe("toolResult");
-  });
-
-  // 2. After detach (unwire), old EventService no longer triggers renders ───────
-
-  it("old EventService does NOT render after unwireAgentRendering (detach)", () => {
-    const events = new EventService();
-    harness.wireAgentRendering("task-1", events, EVENT_TYPES, "Dev");
-
-    // Verify wired first
-    events.emit(EVENT_TYPES.toolCall, { toolCall: {} });
-    expect(harness.rendered).toHaveLength(1);
-    harness.reset();
-
-    // Detach
-    harness.unwireAgentRendering();
-
-    // Emit on the OLD EventService — nothing should render
-    events.emit(EVENT_TYPES.toolCall, { toolCall: {} });
-    events.emit(EVENT_TYPES.agentSay, { message: "zombie" });
-    events.emit(EVENT_TYPES.toolUsed, { toolCall: {}, functionResp: "output" });
-
-    expect(harness.rendered).toHaveLength(0);
-  });
-
-  // 3. Re-attach on a NEW EventService renders correctly ───────────────────────
-
-  it("events on a NEW EventService render after re-wiring (re-attach)", () => {
-    const oldEvents = new EventService();
-    harness.wireAgentRendering("task-1", oldEvents, EVENT_TYPES, "Dev");
-    harness.unwireAgentRendering();
-
-    // Re-attach: new watcher = new EventService
-    const newEvents = new EventService();
-    harness.wireAgentRendering("task-1", newEvents, EVENT_TYPES, "Dev");
-
-    newEvents.emit(EVENT_TYPES.toolCall, { toolCall: { function: { name: "readFile" } } });
-    newEvents.emit(EVENT_TYPES.agentSay, { message: "re-attached message" });
-
-    expect(harness.rendered).toHaveLength(2);
-    expect(harness.rendered[0].type).toBe("toolCall");
-    expect(harness.rendered[0].data.toolCall.function.name).toBe("readFile");
-    expect(harness.rendered[1].type).toBe("agentMessage");
-    expect(harness.rendered[1].data.message).toBe("re-attached message");
-  });
-
-  // 4. Old EventService still silent after re-attach on new EventService ────────
-
-  it("old EventService stays silent after re-attach on new EventService", () => {
-    const oldEvents = new EventService();
-    harness.wireAgentRendering("task-1", oldEvents, EVENT_TYPES, "Dev");
-    harness.unwireAgentRendering();
-
-    const newEvents = new EventService();
-    harness.wireAgentRendering("task-1", newEvents, EVENT_TYPES, "Dev");
-
-    // New events render
-    newEvents.emit(EVENT_TYPES.agentSay, { message: "new" });
-    expect(harness.rendered).toHaveLength(1);
-
-    // Old events still silent
-    oldEvents.emit(EVENT_TYPES.toolCall, { toolCall: {} });
-    oldEvents.emit(EVENT_TYPES.agentSay, { message: "old" });
-    expect(harness.rendered).toHaveLength(1); // unchanged
-  });
-
-  // 5. Double-wire on the SAME EventService does NOT double-render ──────────────
-  //
-  // This is the bug that existed: SessionsModule.attachToFsAgent called
-  // wireAgentRendering, then attachedAgentChatLoop also called it.
-  // Since setListener is keyed (replaces), the net result is one listener —
-  // but the done handler registered by SessionsModule was lost.
-  // The fix removes the extra wireAgentRendering from SessionsModule.
-
-  it("calling wireAgentRendering twice on same EventService does NOT double-render", () => {
-    const events = new EventService();
-
-    // Simulate the OLD (buggy) behavior: SessionsModule wires, then attachedAgentChatLoop wires again
-    harness.wireAgentRendering("task-1", events, EVENT_TYPES, "Dev"); // first call
-    harness.wireAgentRendering("task-1", events, EVENT_TYPES, "Dev"); // second call (setListener replaces)
-
-    events.emit(EVENT_TYPES.toolCall, { toolCall: {} });
-
-    // setListener keyed — only ONE render expected, not two
-    expect(harness.rendered).toHaveLength(1);
-  });
-
-  // 6. Full cycle: attach → emit → detach → re-attach → emit all render correctly
-
-  it("full attach → detach → re-attach cycle: all phases render correctly", () => {
-    // ── First attach ──────────────────────────────────────────────────────────
-    const watcher1 = new EventService();
-    harness.wireAgentRendering("task-A", watcher1, EVENT_TYPES, "Developer");
-
-    watcher1.emit(EVENT_TYPES.toolCall, { toolCall: { function: { name: "execCommand" } } });
-    watcher1.emit(EVENT_TYPES.agentSay, { message: "initial work" });
-    expect(harness.rendered).toHaveLength(2);
-    harness.reset();
-
-    // ── /detach ───────────────────────────────────────────────────────────────
-    harness.unwireAgentRendering();
-
-    // Events from watcher1 after detach should NOT render
-    watcher1.emit(EVENT_TYPES.toolCall, { toolCall: {} });
-    watcher1.emit(EVENT_TYPES.agentSay, { message: "zombie message" });
-    expect(harness.rendered).toHaveLength(0);
-
-    // ── Re-attach (new FsSyncedAgentWatcher creates a new EventService) ───────
-    const watcher2 = new EventService();
-    harness.wireAgentRendering("task-A", watcher2, EVENT_TYPES, "Developer");
-
-    watcher2.emit(EVENT_TYPES.toolCall, { toolCall: { function: { name: "readFile" } } });
-    watcher2.emit(EVENT_TYPES.agentSay, { message: "continuing after re-attach" });
-
-    // THE CRITICAL ASSERTION: renders must arrive after re-attach
-    expect(harness.rendered).toHaveLength(2);
-    expect(harness.rendered[0].type).toBe("toolCall");
-    expect(harness.rendered[0].data.toolCall.function.name).toBe("readFile");
-    expect(harness.rendered[1].type).toBe("agentMessage");
-    expect(harness.rendered[1].data.message).toBe("continuing after re-attach");
-  });
-
-  // 7. toolResult renders after re-attach ──────────────────────────────────────
-
-  it("toolResult events render after re-attach", () => {
-    const events1 = new EventService();
-    harness.wireAgentRendering("task-1", events1, EVENT_TYPES, "Dev");
-    harness.unwireAgentRendering();
-
-    const events2 = new EventService();
-    harness.wireAgentRendering("task-1", events2, EVENT_TYPES, "Dev");
-
-    events2.emit(EVENT_TYPES.toolUsed, {
-      toolCall: { function: { name: "execCommand" } },
-      functionResp: "$ echo hello\nhello",
-    });
-
-    expect(harness.rendered).toHaveLength(1);
-    expect(harness.rendered[0].type).toBe("toolResult");
-    expect(harness.rendered[0].data.functionResp).toBe("$ echo hello\nhello");
-  });
-
-  // 8. Multiple sequential attach/detach cycles all work ───────────────────────
-
-  it("3 sequential attach/detach cycles all render correctly", () => {
-    for (let i = 0; i < 3; i++) {
-      harness.reset();
-      const events = new EventService();
-      harness.wireAgentRendering(`task-${i}`, events, EVENT_TYPES, "Dev");
-
-      events.emit(EVENT_TYPES.agentSay, { message: `cycle ${i}` });
-      expect(harness.rendered).toHaveLength(1);
-      expect(harness.rendered[0].data.message).toBe(`cycle ${i}`);
-      expect(harness.rendered[0].taskId).toBe(`task-${i}`);
-
-      // Detach: old events stop rendering
-      harness.unwireAgentRendering();
-      events.emit(EVENT_TYPES.agentSay, { message: "should not render" });
-      expect(harness.rendered).toHaveLength(1); // still 1, not 2
-    }
-  });
-
-  // 9. hasManagedListener confirms listener is present/absent at right times ───
-
-  it("hasManagedListener reflects wired/unwired state correctly", () => {
-    const events = new EventService();
-
-    // Before wiring: no managed render listeners
-    expect(events.hasManagedListener("agentModule:render:toolCall")).toBe(false);
-    expect(events.hasManagedListener("agentModule:render:agentSay")).toBe(false);
-
-    harness.wireAgentRendering("task-1", events, EVENT_TYPES, "Dev");
-
-    // After wiring: listeners registered
-    expect(events.hasManagedListener("agentModule:render:toolCall")).toBe(true);
-    expect(events.hasManagedListener("agentModule:render:toolUsed")).toBe(true);
-    expect(events.hasManagedListener("agentModule:render:agentSay")).toBe(true);
-
-    harness.unwireAgentRendering();
-
-    // After detach: listeners removed
-    expect(events.hasManagedListener("agentModule:render:toolCall")).toBe(false);
-    expect(events.hasManagedListener("agentModule:render:agentSay")).toBe(false);
-  });
-});