"note": "Heuristic false-green LEADS, not findings. A finding requires a demonstrated reproduction (surviving mutation via mutation-runner). Do not treat a candidate as a confirmed false green. Coverage-theater leads may include tests that delegate their assertion to a custom helper the classifier does not recognise; verify before acting.",

  "sourceDigest": "sha256:dd810dd48c5bdbc9becd7fcc01dd41a4ca2abf0b2d6f6a545907247f6e3e8361",

  "summary": {

    "filesScanned": 2431,

    "filesScanned": 2432,

    "candidateCount": 16,

    "byMode": {

      "false_green_coverage_theater": 15,

{

  "schemaVersion": "1",

  "repository": "OpenAgentsInc/openagents",

  "sourceDigest": "sha256:78a1326f50e5901e25bd56e2bed33f1635fcb75d3dbb89b8bfd8ef4558d00fd3",

  "sourceDigest": "sha256:5ecdc0a7a3a28075c8356671025554ef9c69e4cdc9c25e80eb9b6377bfb567af",

  "surfaces": [

    {

      "id": "app:@openagentsinc/acceptance-runner",

      "oracles": [

        {

          "type": "test",

          "ref": "packages/openagents-cli (31 tracked test files)"

          "ref": "packages/openagents-cli (32 tracked test files)"

        },

        {

          "type": "behavior-contract",

import { CoderTaskRegistry } from "./coder-tasks.js";

import { runCoderUi } from "./coder-ui.js";

import { backendIds } from "./coder-backends.js";

import { OllamaReplySource, isOllamaModelFlag, parseOllamaModelFlag } from "./coder-ollama.js";

import {

  discoverOllamaModel,

  isOllamaModelFlag,

  OllamaReplySource,

  parseOllamaModelFlag,

} from "./coder-ollama.js";

import { openThread, ThreadUnavailable, type ThreadReplySource } from "./coder-thread.js";

import { delegateTool, skillTool } from "./coder-tools.js";

import { loadSkillSelection } from "./coder-skills.js";

      // A `--model` value that starts with `ollama:` goes to the local Ollama

      // server and needs no account credential.

      const wantsOllama = Option.isSome(model) && isOllamaModelFlag(model.value);

      //

      // With no `--model` at all, a machine already running Ollama answers from

      // it. That is the cheaper and more private default, and it is the one a

      // reader who installed Ollama meant: naming the model every time to get

      // the model they already chose is a flag that carries no decision. The

      // hosted backends stay one `--model` away, and `--offline` asks for

      // neither.

      const named = Option.getOrUndefined(model);

      const localModel =

        named === undefined && !offline ? yield* Effect.promise(() => discoverOllamaModel()) : undefined;

      const wantsOllama = named === undefined ? localModel !== undefined : isOllamaModelFlag(named);

      const ollamaName =

        wantsOllama && Option.isSome(model) ? parseOllamaModelFlag(model.value) : undefined;

        named === undefined ? localModel : isOllamaModelFlag(named) ? parseOllamaModelFlag(named) : undefined;

      // Any other `--model` value still has to name a published backend. The

      // flag takes a string so an `ollama:` prefix can reach the local server,

      // which costs the enum `Flag.choice` used to enforce, so the check moves

      // here rather than disappearing.

      if (Option.isSome(model) && !wantsOllama && !backendIds().includes(model.value)) {

      if (named !== undefined && !wantsOllama && !backendIds().includes(named)) {

        return yield* new InputError({

          message: `Unknown model ${model.value}. Use ollama:<model> for a local Ollama server, or one of: ${backendIds().join(", ")}.`,

          message: `Unknown model ${named}. Use ollama:<model> for a local Ollama server, or one of: ${backendIds().join(", ")}.`,

        });

      }

/**

 * Write the conversation as an ATIF trajectory.

 *

 * ATIF -- the Agent Trajectory Interchange Format -- is the shape the rest of

 * this system already speaks: `OpenAgents.DataRights.AtifExport` writes an

 * account's conversation as ATIF v1.7, and the trajectories other agents ship

 * carry the same envelope. Writing anything else here would make a coder

 * session the one thing in the workspace that cannot be read by the tools that

 * read everything else.

 *

 * The mapping is deliberately narrow. A `you` entry is a `user` step; an

 * assistant entry is an `agent` step; reasoning attaches to the step it

 * preceded; a tool entry becomes that step's `tool_calls` and `observation`.

 * Notices are the interface talking to the reader, not the model, so they are

 * not steps -- they are recorded under `extra` where a reader can still see

 * them without a consumer mistaking them for turns.

 */

import { spawnSync } from "node:child_process";

import { mkdirSync, writeFileSync } from "node:fs";

import { homedir } from "node:os";

import { join } from "node:path";

import type { CoderEntry, CoderSnapshot } from "./coder-session.js";

const SCHEMA_VERSION = "ATIF-v1.7";

/**

 * Lines the interface answers itself.

 *

 * They appear in the transcript because the reader typed them, but no model

 * ever saw them, so they are not steps: a trajectory that records `/export` as

 * a turn is describing the act of exporting rather than the work. `/delegate`

 * is not here, because it starts real work whose results the model does read.

 */

const INTERFACE_COMMANDS = /^\/(export|system|skills)\s*$/;

const AGENT_NAME = "openagents-coder";

/** One ATIF step, as the format defines it. */

interface AtifStep {

  step_id: number;

  timestamp: string;

  source: "system" | "user" | "agent";

  message: string;

  model_name?: string;

  reasoning_content?: string;

  tool_calls?: ReadonlyArray<{

    tool_call_id: string;

    function_name: string;

    arguments: Record<string, unknown>;

  }>;

  observation?: { results: ReadonlyArray<{ source_call_id: string; content: string }> };

}

export interface ExportedTrajectory {

  /** Where the file was written. */

  readonly path: string;

  /** Whether the path reached the system clipboard. */

  readonly copied: boolean;

  /** How many steps it holds. */

  readonly steps: number;

}

/** A file name that sorts by time and says what it is. */

const fileName = (repository: string, at: Date): string => {

  const stamp = at.toISOString().replace(/[:.]/g, "-").replace("Z", "Z");

  const safe = repository.replace(/[^A-Za-z0-9._-]/g, "-");

  return `${stamp}-${safe}-atif.json`;

};

/**

 * Arguments as an object, which is what ATIF's `arguments` field is.

 *

 * The interface holds them as the JSON source it renders. Source that will not

 * parse is kept rather than dropped, under a key that says it is unparsed: a

 * trajectory that silently loses what a model asked for is worse than one that

 * says it could not read it.

 */

const argumentsOf = (source: string): Record<string, unknown> => {

  try {

    const parsed = JSON.parse(source) as unknown;

    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)

      ? (parsed as Record<string, unknown>)

      : { value: parsed };

  } catch {

    return { unparsed_arguments: source };

  }

};

/** Fold the transcript into ATIF steps. */

const stepsOf = (entries: ReadonlyArray<CoderEntry>, model: string): ReadonlyArray<AtifStep> => {

  const steps: AtifStep[] = [];

  /** Reasoning arrives before the turn it belongs to and attaches to it. */

  let pendingReasoning: string | undefined;

  for (const entry of entries) {

    const timestamp = new Date(entry.at).toISOString();

    if (entry.role === "notice") continue;

    if (entry.role === "reasoning") {

      pendingReasoning = pendingReasoning === undefined ? entry.text : `${pendingReasoning}\n${entry.text}`;

      continue;

    }

    if (entry.role === "you") {

      if (INTERFACE_COMMANDS.test(entry.text.trim())) continue;

      steps.push({ step_id: steps.length + 1, timestamp, source: "user", message: entry.text });

      continue;

    }

    if (entry.role === "tool" && entry.tool !== undefined) {

      const { callId, name, arguments: args, output, error } = entry.tool;

      steps.push({

        step_id: steps.length + 1,

        timestamp,

        source: "agent",

        message: "",

        model_name: model,

        ...(pendingReasoning === undefined ? {} : { reasoning_content: pendingReasoning }),

        tool_calls: [

          { tool_call_id: callId, function_name: name, arguments: argumentsOf(args) },

        ],

        observation: {

          results: [{ source_call_id: callId, content: error ?? output ?? "" }],

        },

      });

      pendingReasoning = undefined;

      continue;

    }

    if (entry.role === "assistant") {

      // An assistant entry opened and never filled is the caret the interface

      // shows while a chunk is in flight, not a turn the model took.

      if (entry.text.length === 0) continue;

      steps.push({

        step_id: steps.length + 1,

        timestamp,

        source: "agent",

        message: entry.text,

        model_name: model,

        ...(pendingReasoning === undefined ? {} : { reasoning_content: pendingReasoning }),

      });

      pendingReasoning = undefined;

    }

  }

  return steps;

};

/**

 * Put a path on the system clipboard.

 *

 * Best effort by design: a clipboard that is not there is not a reason to fail

 * an export that has already been written. The caller is told whether it

 * landed, and prints the path either way.

 */

const copyToClipboard = (text: string): boolean => {

  const candidates: ReadonlyArray<readonly [string, ReadonlyArray<string>]> =

    process.platform === "darwin"

      ? [["pbcopy", []]]

      : process.platform === "win32"

        ? [["clip", []]]

        : [

            ["wl-copy", []],

            ["xclip", ["-selection", "clipboard"]],

            ["xsel", ["--clipboard", "--input"]],

          ];

  for (const [command, args] of candidates) {

    try {

      const result = spawnSync(command, [...args], { input: text });

      if (result.status === 0) return true;

    } catch {

      continue;

    }

  }

  return false;

};

/**

 * Write the conversation as ATIF and put its path on the clipboard.

 *

 * Written under the home directory rather than the repository: a trajectory is

 * a record of what happened, not a change to the work, and it should not turn

 * up in anyone's `git status`.

 */

export function exportTrajectory(

  snapshot: CoderSnapshot,

  options: {

    readonly model: string;

    readonly toolDefinitions?: ReadonlyArray<Record<string, unknown>> | undefined;

    readonly version: string;

    readonly now?: Date | undefined;

    readonly directory?: string | undefined;

  },

): ExportedTrajectory {

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

  const directory = options.directory ?? join(homedir(), ".openagents", "exports");

  const steps = stepsOf(snapshot.entries, options.model);

  const document = {

    schema_version: SCHEMA_VERSION,

    session_id: `${snapshot.repository}-${at.toISOString()}`,

    trajectory_id: `${snapshot.repository}-${at.toISOString()}`,

    agent: {

      name: AGENT_NAME,

      version: options.version,

      model_name: options.model,

      ...(options.toolDefinitions === undefined

        ? {}

        : { tool_definitions: options.toolDefinitions }),

    },

    steps,

    final_metrics: { total_steps: steps.length },

    extra: {

      exporter: "openagents.coder.atif_export.v1",

      exported_at: at.toISOString(),

      repository: snapshot.repository,

      branch: snapshot.branch,

      // The interface's own lines. Kept because they carry refusals and

      // failures that explain the steps either side of them, and separate

      // because they were never sent to the model.

      notices: snapshot.entries

        .filter((entry) => entry.role === "notice")

        .map((entry) => ({ timestamp: new Date(entry.at).toISOString(), text: entry.text })),

    },

  };

  mkdirSync(directory, { recursive: true });

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

}

  readonly host?: string | undefined;

}

/**

 * The local model to answer from, or undefined when there is no server.

 *

 * Probed with a short deadline because it runs before the first prompt on every

 * session: a machine with no Ollama on it must not pay for the question. A

 * refusal, a timeout, and an empty library are the same answer -- nothing to

 * answer from -- so the caller gets `undefined` for all three rather than a

 * failure to handle.

 *

 * The most recently modified model wins. With one model installed there is no

 * choice to make, and with several the one most recently pulled is the one the

 * reader was last working with.

 */

export const discoverOllamaModel = async (

  host: string = DEFAULT_HOST,

  timeoutMs = 300,

): Promise<string | undefined> => {

  const deadline = AbortSignal.timeout(timeoutMs);

  try {

    const response = await fetch(new URL("/api/tags", host), { signal: deadline });

    if (!response.ok) return undefined;

    const body = (await response.json()) as {

      models?: ReadonlyArray<{ name?: unknown; modified_at?: unknown }>;

    };

    const models = (body.models ?? []).filter(

      (model): model is { name: string; modified_at?: string } => typeof model.name === "string",

    );

    if (models.length === 0) return undefined;

    // Sorting a fresh array, so nothing shared is mutated.

    // eslint-disable-next-line unicorn/no-array-sort -- the spread is the copy

    return [...models].sort((left, right) =>

      String(right.modified_at ?? "").localeCompare(String(left.modified_at ?? "")),

    )[0]?.name;

  } catch {

    return undefined;

  }

};

/** True when `--model` names an Ollama source. */

export const isOllamaModelFlag = (value: string): boolean => value.startsWith("ollama:");

    return parts.join("\n");

  }

  /** The tools as declared, in the shape ATIF records them. */

  toolDefinitions(): ReadonlyArray<Record<string, unknown>> {

    return this.tools.map((tool) => ({

      type: "function",

      function: { name: tool.name, description: tool.description, parameters: tool.parameters },

    }));

  }

  async *reply(prompt: string, signal: AbortSignal): AsyncIterable<ReplyChunk> {

    // Built on the first turn rather than in the constructor: the tools are

    // declared after construction, and the prompt is derived from them.

import type { DelegationOutcome, DelegationRequest } from "./coder-delegate.js";

import { parseDelegateCommand } from "./coder-delegate.js";

import { exportTrajectory } from "./coder-export.js";

import { VERSION } from "./version.js";

import type { CoderTask, CoderTaskId, CoderTaskRegistry } from "./coder-tasks.js";

import type { CoderTool } from "./coder-tools.js";

/** One entry in the transcript. */

export interface CoderEntry {

  readonly role: "you" | "assistant" | "notice" | "tool" | "reasoning";

  /**

   * When this entry was opened, in epoch milliseconds.

   *

   * Kept because a trajectory is a sequence of timed steps: `/export` has to

   * say when each turn happened, and reconstructing that from the order alone

   * would be inventing it.

   */

  readonly at: number;

  /** Rendered text. Streaming entries grow while chunks arrive. */

  text: string;

  /** False while chunks are still arriving, so a renderer can show a caret. */

   * does not compose its own context leaves this undefined.

   */

  describeContext?(): string;

  /**

   * The tools as declared, in the shape a trajectory records them.

   *

   * Optional for the same reason `describeContext` is: a source that declares

   * nothing has nothing to report, and an export then simply omits the field

   * the format already makes optional.

   */

  toolDefinitions?(): ReadonlyArray<Record<string, unknown>>;

  /**

   * Yield the reply to `prompt` in chunks. Rendering appends each chunk as it

   * arrives, so a slow source shows partial text rather than nothing.

  }

  notice(text: string): void {

    this.entries.push({ role: "notice", text, settled: true });

    this.entries.push({ role: "notice", text, settled: true, at: Date.now() });

    this.emit();

  }

    // shows it as a notice, and sends nothing. A reader checking what the model

    // was told should not have to change what the model was told to find out.

    if (/^\/system\s*$/.test(prompt.trim())) {

      this.entries.push({ role: "you", text: prompt, settled: true });

      this.entries.push({ role: "you", text: prompt, settled: true, at: Date.now() });

      const context = this.source.describeContext?.();

      this.notice(

        context === undefined

      return;

    }

    // `/export` is not a turn either: it writes what has already happened.

    if (/^\/export\s*$/.test(prompt.trim())) {

      this.entries.push({ role: "you", text: prompt, settled: true, at: Date.now() });

      try {

        const written = exportTrajectory(this.snapshot(), {

          model: this.source.model,

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

          version: VERSION,

        });

        this.notice(

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

            (written.copied ? " (path copied to the clipboard)." : "."),

        );

      } catch (cause) {

        this.notice(

          `The export could not be written: ${cause instanceof Error ? cause.message : String(cause)}`,

        );

      }

      this.emit();

      return;

    }

    const delegate = parseDelegateCommand(prompt);

    if (delegate !== undefined) {

      this.entries.push({ role: "you", text: prompt, settled: true });

      this.entries.push({ role: "you", text: prompt, settled: true, at: Date.now() });

      this.startDelegation(delegate.count, delegate.prompt, delegate.description);

      this.emit();

      return;

    if (this.controller !== undefined) return;

    this.entries.push({ role: "you", text: prompt, settled: true });

    this.entries.push({ role: "you", text: prompt, settled: true, at: Date.now() });

    // An empty assistant entry from the start, so the interface shows a caret

    // rather than nothing while the first chunk is in flight. It is withdrawn

    // if the turn opens with reasoning or a tool call instead of text.

    const opening: CoderEntry = { role: "assistant", text: "", settled: false };

    const opening: CoderEntry = { role: "assistant", text: "", settled: false, at: Date.now() };

    this.entries.push(opening);

    /** The entry each streaming chunk kind is currently appending to. */

          if (text === undefined) {

            settle(reasoning);

            reasoning = undefined;

            text = { role: "assistant", text: "", settled: false };

            text = { role: "assistant", text: "", settled: false, at: Date.now() };

            this.entries.push(text);

          }

          text.text += chunk.value;

            if (text === opening) withdrawOpening();

            settle(text);

            text = undefined;

            reasoning = { role: "reasoning", text: "", settled: false };

            reasoning = { role: "reasoning", text: "", settled: false, at: Date.now() };

            this.entries.push(reasoning);

          }

          reasoning.text += chunk.value;

            role: "tool",

            text: chunk.name,

            settled: false,

            at: Date.now(),

            tool: {

              callId: chunk.callId,

              name: chunk.name,

        this.entries.splice(this.entries.indexOf(text), 1);

        text = undefined;

      }

      this.entries.push({ role: "notice", text: message, settled: true });

      this.entries.push({ role: "notice", text: message, settled: true, at: Date.now() });

    } finally {

      for (const entry of this.entries) {

        if (entry.settled) continue;

   * process never saw. A `/system` that guessed would be worse than one that

   * admits the boundary.

   */

  /** The tools as declared, in the shape ATIF records them. */

  toolDefinitions(): ReadonlyArray<Record<string, unknown>> {

    return this.tools.map((tool) => ({

      type: "function",

      function: { name: tool.name, description: tool.description, parameters: tool.parameters },

    }));

  }

  describeContext(): string {

    const declarations =

      this.tools.length === 0

    session.notice(

      "openagents coder — development build. Type a message and press enter. " +

        "Ctrl+D quits, Esc interrupts a reply. `/system` shows what the model is told, " +

        "`/skills` chooses which skills it is offered.",

        "`/skills` chooses which skills it is offered, `/export` writes the conversation " +

        "as ATIF.",

    );

    render();

  });

import { mkdtempSync, readFileSync, readdirSync } from "node:fs";

import { tmpdir } from "node:os";

import { join } from "node:path";

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

import { exportTrajectory } from "../src/coder-export.js";

import type { CoderEntry, CoderSnapshot } from "../src/coder-session.js";

const AT = Date.parse("2026-08-24T14:00:00.000Z");

const entry = (partial: Partial<CoderEntry> & Pick<CoderEntry, "role">): CoderEntry => ({

  text: "",

  settled: true,

  at: AT,

  ...partial,

});

const snapshot = (entries: ReadonlyArray<CoderEntry>): CoderSnapshot =>

  ({

    entries,

    repository: "openagents.com",

    branch: "main",

    model: "Ollama qwen",

    turns: 1,

    running: false,

    tasks: [],

  }) as unknown as CoderSnapshot;

const write = (entries: ReadonlyArray<CoderEntry>) => {

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

  const result = exportTrajectory(snapshot(entries), {

    model: "Ollama qwen",

    version: "0.3.5",

    now: new Date(AT),

    directory,

  });

  return {

    result,

    directory,

    document: JSON.parse(readFileSync(result.path, "utf8")) as Record<string, unknown>,

  };

};

describe("exporting a conversation as ATIF", () => {

  it("writes the envelope the rest of the system reads", () => {

    const { document, result } = write([entry({ role: "you", text: "hello" })]);

    expect(document["schema_version"]).toBe("ATIF-v1.7");

    expect(document["agent"]).toMatchObject({ name: "openagents-coder", version: "0.3.5" });

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

    expect(result.path).toContain("openagents.com-atif.json");

  });

  it("numbers steps from one and names each source", () => {

    const { document } = write([

      entry({ role: "you", text: "ask" }),

      entry({ role: "assistant", text: "answer" }),

    ]);

    expect(document["steps"]).toEqual([

      expect.objectContaining({ step_id: 1, source: "user", message: "ask" }),

      expect.objectContaining({ step_id: 2, source: "agent", message: "answer" }),

    ]);

  });

  it("carries a tool call and its result on one agent step", () => {

    const { document } = write([

      entry({

        role: "tool",

        text: "skill",

        tool: {

          callId: "call-1",

          name: "skill",

          arguments: '{"name":"house-style"}',

          output: "Use sentence case.",

          error: undefined,

          status: "succeeded",

        },

      }),

    ]);

    const [step] = document["steps"] as ReadonlyArray<Record<string, unknown>>;

    expect(step).toMatchObject({

      source: "agent",

      message: "",

      tool_calls: [

        { tool_call_id: "call-1", function_name: "skill", arguments: { name: "house-style" } },

      ],

      observation: { results: [{ source_call_id: "call-1", content: "Use sentence case." }] },

    });

  });

  it("reports a failed call by its error, not as an empty result", () => {

    const { document } = write([

      entry({

        role: "tool",

        text: "delegate",

        tool: {

          callId: "call-2",

          name: "delegate",

          arguments: "{}",

          output: undefined,

          error: "the fleet is full",

          status: "failed",

        },

      }),

    ]);

    const [step] = document["steps"] as ReadonlyArray<Record<string, unknown>>;

    expect(step).toMatchObject({

      observation: { results: [{ content: "the fleet is full" }] },

    });

  });

  it("keeps arguments it cannot parse rather than dropping them", () => {

    const { document } = write([

      entry({

        role: "tool",

        text: "skill",

        tool: {

          callId: "call-3",

          name: "skill",

          arguments: "{not json",

          output: "",

          error: undefined,

          status: "succeeded",

        },

      }),

    ]);

    const [step] = document["steps"] as ReadonlyArray<Record<string, unknown>>;

    // A trajectory that silently loses what a model asked for is worse than one

    // that says it could not read it.

    expect(step).toMatchObject({

      tool_calls: [{ arguments: { unparsed_arguments: "{not json" } }],

    });

  });

  it("attaches reasoning to the step it preceded", () => {

    const { document } = write([

      entry({ role: "reasoning", text: "weighing it" }),

      entry({ role: "assistant", text: "answer" }),

    ]);

    expect(document["steps"]).toEqual([

      expect.objectContaining({ source: "agent", reasoning_content: "weighing it" }),

    ]);

  });

  it("keeps notices out of the steps and in the record", () => {

    const { document } = write([

      entry({ role: "you", text: "ask" }),

      entry({ role: "notice", text: "Delegation refused (quota)." }),

    ]);

    // A notice is the interface talking to the reader. It never reached the

    // model, so it is not a step, but it explains the steps either side of it.

    expect(document["steps"]).toHaveLength(1);

    expect((document["extra"] as Record<string, unknown>)["notices"]).toEqual([

      expect.objectContaining({ text: "Delegation refused (quota)." }),

    ]);

  });

  it("leaves out the commands the interface answers itself", () => {

    const { document } = write([

      entry({ role: "you", text: "/export" }),

      entry({ role: "you", text: "/system" }),

      entry({ role: "you", text: "/skills" }),

      entry({ role: "you", text: "a real question" }),

    ]);

    expect(document["steps"]).toEqual([

      expect.objectContaining({ message: "a real question" }),

    ]);

  });

  it("leaves out the empty entry the interface opens for the caret", () => {

    const { document } = write([

      entry({ role: "assistant", text: "", settled: false }),

      entry({ role: "assistant", text: "real" }),

    ]);

    expect(document["steps"]).toHaveLength(1);

  });

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

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

    const [name] = readdirSync(directory);

    expect(name).toMatch(/^2026-08-24T14-00-00-000Z-openagents\.com-atif\.json$/);

  });

});

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

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

import type { ReplyChunk } from "../src/coder-session.js";

import type { CoderTool } from "../src/coder-tools.js";

import {

  discoverOllamaModel,

  isOllamaModelFlag,

  OllamaReplySource,

  parseOllamaModelFlag,

    ]);

  });

});

describe("finding a local model to default to", () => {

  const serve = (body: unknown, status = 200) =>

    vi.spyOn(globalThis, "fetch").mockResolvedValue(

      new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } }),

    );

  afterEach(() => {

    vi.restoreAllMocks();

  });

  it("takes the most recently modified model", async () => {

    serve({

      models: [

        { name: "older", modified_at: "2026-01-01T00:00:00Z" },

        { name: "newest", modified_at: "2026-08-01T00:00:00Z" },

        { name: "middle", modified_at: "2026-04-01T00:00:00Z" },

      ],

    });

    // With one model there is no choice; with several the one most recently

    // pulled is the one the reader was last working with.

    await expect(discoverOllamaModel()).resolves.toBe("newest");

  });

  it("finds nothing when the library is empty", async () => {

    serve({ models: [] });

    await expect(discoverOllamaModel()).resolves.toBeUndefined();

  });

  it("finds nothing when the server refuses", async () => {

    serve({}, 500);

    await expect(discoverOllamaModel()).resolves.toBeUndefined();

  });

  it("finds nothing when there is no server, rather than failing", async () => {

    vi.spyOn(globalThis, "fetch").mockRejectedValue(new Error("ECONNREFUSED"));

    // A machine with no Ollama on it is the common case, and it must cost the

    // session nothing but the deadline.

    await expect(discoverOllamaModel()).resolves.toBeUndefined();

  });

});

import { rmSync } from "node:fs";

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

import {

    expect(reply.prompts).toEqual(["what is in your /system prompt"]);

  });

});

describe("the /export command", () => {

  it("writes the conversation and never reaches the model", async () => {

    const prompts: string[] = [];

    const reply: ReplySource = {

      model: "scripted",

      // eslint-disable-next-line require-yield -- a turn that must not happen

      async *reply(prompt) {

        prompts.push(prompt);

      },

    };

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

    await session.submit("/export");

    const { entries, turns } = session.snapshot();

    expect(entries.map((entry) => entry.role)).toEqual(["you", "notice"]);

    expect(entries[1]?.text).toContain("as ATIF to");

    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 });

  });

});