type TrajectoryExportApprovalEntry = {

id?: string;

command?: string;

commandArgv?: string[];

commandText?: string;

commandPreview?: string;

request?: {

command?: string;

commandArgv?: string[];

commandText?: string;

commandPreview?: string;

};

hasTrajectoryExportCommand: boolean;

};

type TrajectoryExportSignal = {

approvalId?: string;

instructionText: string;

};

function logLiveStep(step: string, details?: Record<string, unknown>): void {

if (!CODEX_HARNESS_DEBUG) {

return;

function getTrajectoryExportApprovalCommands(entry: TrajectoryExportApprovalEntry): string[] {

return [

entry.request?.command,

entry.request?.commandArgv?.join(" "),

entry.request?.commandText,

entry.request?.commandPreview,

entry.command,

entry.commandArgv?.join(" "),

entry.commandText,

entry.commandPreview,

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

return summary;

}

async function waitForTrajectoryExportInstructionText(params: {

async function waitForTrajectoryExportSignal(params: {

client: GatewayClient;

events: EventFrame[];

eventStartIndex: number;

expectedText: string;

runId: string;

sessionKey: string;

timeoutMs: number;

}): Promise<string> {

}): Promise<TrajectoryExportSignal> {

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

let finalTexts: string[] = [];

let assistantTexts: string[] = [];

let finalTexts: string[] | undefined;

let assistantTexts: string[] | undefined;

let approvalId: string | undefined;

let nextHistoryPollAt = 0;

while (Date.now() < deadline) {

const newEvents = params.events.slice(params.eventStartIndex);

.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;

return { ...(approvalId ? { approvalId } : {}), instructionText: matchedText };

}

if (Date.now() >= nextHistoryPollAt) {

try {

text.includes(params.expectedText),

);

if (matchedHistoryText) {

return matchedHistoryText;

return { ...(approvalId ? { approvalId } : {}), instructionText: matchedHistoryText };

}

} catch {

assistantTexts = [];

}

try {

const approvals = (await params.client.request(

"exec.approval.list",

{},

{ timeoutMs: 10_000 },

)) as TrajectoryExportApprovalEntry[];

const approval = approvals.find(isTrajectoryExportApproval);

if (approval && !approvalId) {

approvalId = await approveTrajectoryExport(params.client, approval);

}

} catch {}

nextHistoryPollAt = Date.now() + 2_000;

}

await new Promise((resolve) => {

}

throw new Error(

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

`events=${params.events.length}; finalTexts=${formatTextPreview(finalTexts)}; assistantTexts=${formatTextPreview(assistantTexts)}; approvals=${JSON.stringify(approvalSummaries)}`,

`events=${params.events.length}; approved=${approvalId ?? "<none>"}; finalTexts=${formatTextPreview(finalTexts ?? [])}; assistantTexts=${formatTextPreview(assistantTexts ?? [])}; approvals=${JSON.stringify(approvalSummaries)}`,

);

}

return text || undefined;

}

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

async function approveTrajectoryExport(

client: GatewayClient,

existingApproval?: TrajectoryExportApprovalEntry,

): Promise<string> {

const startedAt = Date.now();

let approval: TrajectoryExportApprovalEntry | undefined;

let approval: TrajectoryExportApprovalEntry | undefined = existingApproval;

let lastApprovalSummaries: TrajectoryExportApprovalSummary[] = [];

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

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

const approvals = (await client.request(

"exec.approval.list",

{},

exportResponse?.status === "ok" ||

exportResponse?.status === "started",

).toBe(true);

const finalText =

const exportSignal: TrajectoryExportSignal =

typeof exportResponse?.message === "object"

? extractVisibleMessageText(exportResponse.message)

: await waitForTrajectoryExportInstructionText({

? { instructionText: extractVisibleMessageText(exportResponse.message) ?? "" }

: await waitForTrajectoryExportSignal({

client,

events: gatewayEvents,

eventStartIndex: exportEventStartIndex,

sessionKey,

timeoutMs: TRAJECTORY_EXPORT_INSTRUCTION_TIMEOUT_MS,

});

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

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

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

const approvalId = await approveTrajectoryExport(client);

expect(exportSignal.instructionText).toContain("Trajectory exports can include");

expect(exportSignal.instructionText).toContain("through exec approval");

expect(exportSignal.instructionText).toContain("Approve once");

const approvalId = exportSignal.approvalId ?? (await approveTrajectoryExport(client));

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

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

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

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

const bundleNames = await listDirectoryNames(bundleDir);

for (const expectedName of [

"artifacts.json",