readonly version: string;

    readonly now?: Date | undefined;

    readonly directory?: string | undefined;

    /**

     * Whether the path goes to the system clipboard. On by default.

     *

     * Off for anything that is not a person exporting: a test that took the

     * clipboard replaced a reader's own export path with one pointing at a file

     * the test then deleted, and the reader pasted it and was told the path did

     * not exist.

     */

    readonly copy?: boolean | undefined;

  },

): ExportedTrajectory {

  const at = options.now ?? new Date();

  const path = join(directory, fileName(snapshot.repository, at));

  writeFileSync(path, `${JSON.stringify(document, undefined, 2)}\n`, "utf8");

  return { path, copied: copyToClipboard(path), steps: steps.length };

  const copy = options.copy ?? true;

  return { path, copied: copy && copyToClipboard(path), steps: steps.length };

}

     * buys nothing.

     */

    private readonly standing?: string,

    /**

     * Where `/export` writes, and whether it takes the clipboard.

     *

     * For tests. A suite that wrote into the reader's own export directory and

     * took their clipboard is a suite that changed the machine it was checking.

     */

    private readonly exports?: { readonly directory: string },

  ) {

    // A child reporting progress has to reach the renderer, and the renderer

    // subscribes to the session rather than to the registry, so the session

          model: this.source.modelId ?? this.source.model,

          toolDefinitions: this.source.toolDefinitions?.(),

          version: VERSION,

          ...(this.exports === undefined

            ? {}

            : { directory: this.exports.directory, copy: false }),

        });

        this.notice(

          `Exported ${String(written.steps)} step${written.steps === 1 ? "" : "s"} as ATIF to ${written.path}` +

    version: "0.3.5",

    now: new Date(AT),

    directory,

    // A suite must not take the reader's clipboard.

    copy: false,

  });

  return {

    result,

    expect(document["final_metrics"]).toEqual({ total_steps: 1 });

  });

  it("takes the clipboard only when asked to", () => {

    const directory = mkdtempSync(join(tmpdir(), "coder-export-"));

    // The default is a person exporting, and they want the path. Anything else

    // — a test above all — must say so: a suite that took the clipboard once

    // replaced a reader's own export path with one pointing at a file the suite

    // then deleted, and the reader pasted it and was told it did not exist.

    const quiet = exportTrajectory(snapshot([entry({ role: "you", text: "hi" })]), {

      model: "m",

      version: "0",

      now: new Date(AT),

      directory,

      copy: false,

    });

    expect(quiet.copied).toBe(false);

  });

  it("writes one file per export, named so they sort by time", () => {

    const { directory } = write([entry({ role: "you", text: "one" })]);

import { rmSync } from "node:fs";

import { mkdtempSync } from "node:fs";

import { tmpdir } from "node:os";

import { join } from "node:path";

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

import {

        prompts.push(prompt);

      },

    };

    const session = new CoderSession(reply, "repo", "main");

    // Its own directory, and no clipboard: a test that writes where a reader

    // exports, and takes their clipboard, changes the machine it is checking.

    const directory = mkdtempSync(join(tmpdir(), "coder-session-export-"));

    const session = new CoderSession(reply, "repo", "main", undefined, undefined, { directory });

    await session.submit("/export");

    expect(prompts).toEqual([]);

    expect(turns).toBe(0);

    // The wiring writes a real file. Take it away again: a test suite should

    // not leave anything behind in the directory a person exports into.

    const written = /as ATIF to (\S+\.json)/.exec(entries[1]?.text ?? "")?.[1];

    if (written !== undefined) rmSync(written, { force: true });

    // Written into the test's own directory, so there is nothing to clean out

    // of the reader's.

    expect(entries[1]?.text).toContain(directory);

  });

});