import fs from "node:fs";

import { describe, expect, it, vi } from "vitest";

import { repairToolUseResultPairing } from "../../agents/session-transcript-repair.js";

import * as transcriptEvents from "../../sessions/transcript-events.js";

import type { SessionTranscriptUpdate } from "../../sessions/transcript-events.js";

import { resolveSessionTranscriptPathInDir } from "./paths.js";

type ExactAssistantMessage = Parameters<

typeof appendExactAssistantMessageToSessionTranscript

>[0]["message"];

type TranscriptRepairMessage = Parameters<typeof repairToolUseResultPairing>[0][number];

type TranscriptUpdateEmitterSpy = {

mock: {

calls: [string | SessionTranscriptUpdate][];

}

});

it("keeps delivery mirrors in transcripts while repair preserves real tool results", async () => {

writeTranscriptStore();

const sessionFile = resolveSessionTranscriptPathInDir(sessionId, fixture.sessionsDir());

const toolCallId = "call_maniple_list";

const toolCallResult = await appendSessionTranscriptMessage({

transcriptPath: sessionFile,

message: {

role: "assistant",

content: [

{

type: "toolCall",

id: toolCallId,

name: "maniple__list_workers",

arguments: {},

},

],

stopReason: "toolUse",

},

});

const mirrorResult = await appendAssistantMessageToSessionTranscript({

sessionKey,

text: "Maniple List Workers",

storePath: fixture.storePath(),

});

expect(mirrorResult.ok).toBe(true);

if (!mirrorResult.ok) {

return;

}

expect(mirrorResult.messageId).not.toBe(toolCallResult.messageId);

const linesAfterMirror = fs.readFileSync(sessionFile, "utf-8").trim().split("\n");

expect(linesAfterMirror).toHaveLength(3);

const mirrorLine = JSON.parse(linesAfterMirror[2]);

expect(mirrorLine.message.model).toBe("delivery-mirror");

await appendSessionTranscriptMessage({

transcriptPath: sessionFile,

message: {

role: "toolResult",

toolCallId,

toolName: "maniple__list_workers",

content: [{ type: "text", text: "workers listed" }],

isError: false,

},

});

const messages = fs

.readFileSync(sessionFile, "utf-8")

.trim()

.split("\n")

.map((line) => JSON.parse(line) as { message?: TranscriptRepairMessage })

.flatMap((entry) => (entry.message ? [entry.message] : []));

expect(messages.map((message) => message.role)).toEqual([

"assistant",

"assistant",

"toolResult",

]);

const repair = repairToolUseResultPairing(messages, {

missingToolResultText: "aborted",

});

expect(repair.added).toHaveLength(0);

expect(repair.messages.map((message) => message.role)).toEqual([

"assistant",

"toolResult",

"assistant",

]);

expect((repair.messages[2] as { model?: string }).model).toBe("delivery-mirror");

});

it("finds session entry using normalized (lowercased) key", async () => {

const storeKey = "agent:main:imessage:direct:+15551234567";

const store = {