throw new Error(`timed out waiting for ${filePath}`);

}

function extractAssistantTexts(messages: unknown[]): string[] {

const texts: string[] = [];

for (const entry of messages) {

if (!entry || typeof entry !== "object") {

continue;

}

if ((entry as { role?: unknown }).role !== "assistant") {

continue;

}

const text = extractFirstTextBlock(entry);

if (typeof text === "string" && text.trim().length > 0) {

texts.push(text);

}

}

return texts;

}

function formatAssistantTextPreview(texts: string[], maxChars = 800): string {

function formatTextPreview(texts: string[], maxChars = 800): string {

const combined = texts.join("\n\n").trim();

if (!combined) {

return "<none>";

}

async function waitForTrajectoryExportInstructionText(params: {

client: GatewayClient;

events: EventFrame[];

expectedText: string;

runId: string;

sessionKey: string;

timeoutMs: number;

}): Promise<string> {

const deadline = Date.now() + params.timeoutMs;

let lastAssistantTexts: string[] = [];

let finalTexts: string[] = [];

while (Date.now() < deadline) {

const eventText = params.events

finalTexts = params.events

.map((event) => extractChatFinalText(event, params.runId))

.find(Boolean);

if (eventText) {

return eventText;

}

const sessionEventText = params.events

.map((event) => extractChatFinalTextForSession(event, params.sessionKey))

.find((text) => text?.includes(params.expectedText));

if (sessionEventText) {

return sessionEventText;

}

const history: { messages?: unknown[] } = await params.client.request(

"chat.history",

{

sessionKey: params.sessionKey,

limit: 24,

},

{ timeoutMs: 10_000 },

);

lastAssistantTexts = extractAssistantTexts(history.messages ?? []);

const historyText = lastAssistantTexts.find((text) => text.includes(params.expectedText));

if (historyText) {

return historyText;

.filter((text): text is string => typeof text === "string" && text.trim().length > 0);

const matchedText = finalTexts.find((text) => text.includes(params.expectedText));

if (matchedText) {

return matchedText;

}

await new Promise((resolve) => {

setTimeout(resolve, 500);

});

}

throw new Error(

`timed out waiting for trajectory export instruction text for ${params.runId}; ` +

`events=${params.events.length}; assistantTexts=${formatAssistantTextPreview(lastAssistantTexts)}`,

`events=${params.events.length}; finalTexts=${formatTextPreview(finalTexts)}`,

);

}

if (record.runId !== runId || record.state !== "final") {

return undefined;

}

return extractChatFinalRecordText(record);

}

function extractChatFinalTextForSession(event: EventFrame, sessionKey: string): string | undefined {

if (event.event !== "chat") {

return undefined;

}

const payload = event.payload;

if (!payload || typeof payload !== "object") {

return undefined;

}

const record = payload as Record<string, unknown>;

if (record.sessionKey !== sessionKey || record.state !== "final") {

return undefined;

}

return extractChatFinalRecordText(record);

}

function extractChatFinalRecordText(record: Record<string, unknown>): string | undefined {

const message = record.message;

if (!message || typeof message !== "object") {

return undefined;

}

const messageRecord = message as Record<string, unknown>;

if (typeof messageRecord.text === "string" && messageRecord.text.trim()) {

return messageRecord.text;

}

const content = Array.isArray(messageRecord.content) ? messageRecord.content : [];

return content

.map((entry) =>

entry && typeof entry === "object" ? (entry as Record<string, unknown>).text : undefined,

)

.filter((entry): entry is string => typeof entry === "string" && entry.trim().length > 0)

.join("\n")

.trim();

const messageRecord = message as { text?: unknown };

return typeof messageRecord.text === "string"

? messageRecord.text

: extractFirstTextBlock(message);

}

async function approveTrajectoryExport(client: GatewayClient): Promise<string> {

};

}

| undefined;

let lastApprovalCommands: string[] = [];

while (Date.now() - startedAt < 60_000) {

const approvals = (await client.request(

"exec.approval.list",

command?: string;

};

}>;

lastApprovalCommands = approvals

.map((entry) => entry.request?.command)

.filter((command): command is string => typeof command === "string");

approval = approvals.find((entry) =>

entry.request?.command?.includes("sessions export-trajectory"),

);

setTimeout(resolve, 500);

});

}

expect(typeof approval?.id).toBe("string");

expect(approval?.request?.command).toContain("sessions export-trajectory");

if (!approval?.id) {

throw new Error("expected trajectory export approval id");

throw new Error(

`expected trajectory export approval id; approvals=${JSON.stringify(lastApprovalCommands)}`,

);

}

expect(approval.request?.command).toContain("sessions export-trajectory");

await client.request(

"exec.approval.resolve",

{ id: approval.id, decision: "allow-once" },

typeof exportResponse?.message === "object"

? extractFirstTextBlock(exportResponse.message)

: await waitForTrajectoryExportInstructionText({

client,

events: gatewayEvents,

expectedText: "Trajectory exports can include",

runId: exportRunId,

sessionKey,

timeoutMs: 60_000,

});

expect(finalText).toContain("Trajectory exports can include");

expect(finalText).toContain("through exec approval");

expect(finalText).toContain("Approve once");

const approvalId = await approveTrajectoryExport(client);

logLiveStep("export:approved", { approvalId });

await waitForPath(path.join(bundleDir, "events.jsonl"), 60_000);

logLiveStep("export:done", { finalText });

expect(finalText).toContain("Approve once");

logLiveStep("export:done", { approvalId, finalText });

const bundleNames = await listDirectoryNames(bundleDir);

for (const expectedName of [

"artifacts.json",