Codeman/test/agent-skill-local-model.test.ts

/**
 * @fileoverview The codeman skill's local model helpers: `local_model`, the `local` worker kind
 * of `spawn_worker`, and `sendmark`.
 *
 * Runs the REAL `skills/codeman/preamble.sh` in bash with `CURL` replaced by a stub that plays a
 * fake Codeman: it records every request (method, route, query, body) in order and answers from
 * files the test wrote, one per route and optionally one per call of that route. So these check
 * what the functions put on the wire and what they make of each answer, never a copy of their
 * logic, and nothing here talks to a real server.
 *
 * Port: N/A (no server; the stub answers every request).
 */

import { afterEach, describe, expect, it } from 'vitest';
import { execFileSync, spawnSync } from 'node:child_process';
import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';

const PREAMBLE = join(__dirname, '..', 'skills', 'codeman', 'preamble.sh');
const API = 'http://127.0.0.1:9';
const SELF = 'caller-session-0000';
const SID = 'worker-local-0001';

// The preamble builds every request body with jq.
let hasJq = true;
try {
  execFileSync('jq', ['--version'], { stdio: 'ignore' });
} catch {
  hasJq = false;
}

/**
 * The fake Codeman. Each call is appended to $CALLS as one JSON line, then answered from
 * $ANSWERS/<route>.<n> (the n-th call of that route) or $ANSWERS/<route>. `<file>.code` is the
 * HTTP status `-w` reports (default 200) and `<file>.delay` seconds to sleep first. A wait-output
 * for `DONE_<token>` writes $WD/codeman-answer-<token>.md first when $ANSWER_TEXT is set, or a
 * symlink to $ANSWER_SYMLINK, the way a worker would before printing its marker.
 *
 * Written without a single dollar-brace, because this is a JS template literal.
 */
const STUB = String.raw`
stub() {
  local m=GET u='' d='' q='' w='' route key n f tok
  while [ "$#" -gt 0 ]; do
    case "$1" in
      -X) m=$2; shift ;;
      -d|--data-binary) d=$2; shift ;;
      --data-urlencode) q="$q&$2"; shift ;;
      -w) w=$2; shift ;;
      -H|-u|-o) shift ;;
      http*) u=$1 ;;
    esac
    shift
  done
  route=$(printf '%s' "$u" | sed "s|^$CODEMAN_API_URL/api/v1/||")
  case "$route" in
    local-model) key=lm-get ;;
    local-model/runtime) key=lm-runtime ;;
    quick-start) key=quick-start ;;
    sessions/*/*) key=$(basename "$route") ;;
    sessions/*) if [ "$m" = DELETE ]; then key=delete; else key=session; fi ;;
    *) key=other ;;
  esac
  jq -nc --arg m "$m" --arg k "$key" --arg q "$q" --arg d "$d" '{m:$m,key:$k,q:$q,d:$d}' >> "$CALLS"
  n=$(grep -cF "\"key\":\"$key\"" "$CALLS")
  f="$ANSWERS/$key.$n"; [ -f "$f" ] || f="$ANSWERS/$key"
  if [ "$key" = wait-output ]; then
    case "$q" in *match=DONE_*)
      tok=$(printf '%s' "$q" | sed -e 's/.*match=DONE_//' -e 's/&.*//')
      if [ -n "$ANSWER_TEXT" ]; then printf '%s' "$ANSWER_TEXT" > "$WD/codeman-answer-$tok.md"; fi
      if [ -n "$ANSWER_SYMLINK" ]; then ln -s "$ANSWER_SYMLINK" "$WD/codeman-answer-$tok.md"; fi ;;
    esac
  fi
  [ -f "$f.delay" ] && sleep "$(cat "$f.delay")"
  if [ -f "$f" ]; then cat "$f"; else printf '%s' '{"success":false,"error":"no stub answer","errorCode":"NOT_FOUND"}'; fi
  if [ -n "$w" ]; then printf '\n%s' "$(cat "$f.code" 2>/dev/null || echo 200)"; fi
}
CURL=(stub)
`;

interface Call {
  m: string;
  key: string;
  q: string;
  d: string;
}

interface Run {
  rc: number | null;
  stdout: string;
  stderr: string;
  calls: Call[];
  wd: string;
}

const dirs: string[] = [];
afterEach(() => {
  for (const dir of dirs.splice(0)) rmSync(dir, { recursive: true, force: true });
});

/** Sources the preamble, installs the stub, runs `body`, and returns what happened. */
function runSkill(body: string, answers: Record<string, string> = {}, env: Record<string, string> = {}): Run {
  const dir = mkdtempSync(join(tmpdir(), 'codeman-local-skill-'));
  dirs.push(dir);
  const answerDir = join(dir, 'answers');
  const wd = join(dir, 'wd');
  const calls = join(dir, 'calls');
  mkdirSync(answerDir);
  mkdirSync(wd);
  writeFileSync(calls, '');
  for (const [name, content] of Object.entries(answers)) writeFileSync(join(answerDir, name), content);
  const res = spawnSync('bash', ['-c', `. "$PREAMBLE" >/dev/null\n${STUB}\n${body}`], {
    encoding: 'utf-8',
    timeout: 20_000,
    env: {
      PATH: process.env.PATH,
      HOME: process.env.HOME,
      PREAMBLE,
      CALLS: calls,
      ANSWERS: answerDir,
      WD: wd,
      CODEMAN_API_URL: API,
      CODEMAN_SESSION_ID: SELF,
      ...env,
    },
  });
  const callList = readFileSync(calls, 'utf-8')
    .split('\n')
    .filter(Boolean)
    .map((line) => JSON.parse(line) as Call);
  return { rc: res.status, stdout: res.stdout, stderr: res.stderr, calls: callList, wd };
}

/** The `data` of GET /api/local-model, as the server builds it. */
function status(install: Record<string, unknown>, recommendation: Record<string, unknown> = {}): string {
  return JSON.stringify({
    success: true,
    data: {
      hardware: { platform: 'darwin' },
      recommendation: { verdict: 'ok', headline: { text: 'A model fits.' }, ...recommendation },
      catalogUpdated: '2026-11-06',
      install: { running: false, actions: [], ...install },
    },
  });
}

const INSTALLED = {
  state: 'installed',
  cli: 'opencode',
  cliLabel: 'OpenCode',
  endpointId: 'local-ollama',
  model: { id: 'qwen3.6:35b-a3b', label: 'Qwen3.6 35B-A3B' },
};
const RUNNING = status({ ...INSTALLED, running: true, actions: ['start-session', 'stop', 'remove'] });
const STOPPED = status({ ...INSTALLED, running: false, actions: ['start', 'remove'] });
const QUICK_START = JSON.stringify({ success: true, data: { sessionId: SID, casePath: '/tmp/summ' } });
const MATCHED = JSON.stringify({ success: true, data: { wait: { matched: true, timedOut: false, ended: false } } });
const NOT_MATCHED = JSON.stringify({ success: true, data: { wait: { matched: false, timedOut: true, ended: false } } });

function lastJson(stdout: string): Record<string, unknown> {
  const lines = stdout.trim().split('\n');
  return JSON.parse(lines[lines.length - 1]) as Record<string, unknown>;
}

describe.skipIf(!hasJq)('preamble local_model', () => {
  const cases: Array<{ name: string; body: string; code?: string; rc: number; expect: Record<string, unknown> }> = [
    {
      name: 'a running model: spawnable now, with the harness, endpoint and model',
      body: RUNNING,
      rc: 0,
      expect: {
        spawnable: true,
        running: true,
        cli: 'opencode',
        cliLabel: 'OpenCode',
        endpointId: 'local-ollama',
        modelId: 'qwen3.6:35b-a3b',
        modelLabel: 'Qwen3.6 35B-A3B',
      },
    },
    {
      name: 'an installed model whose runtime is stopped: spawnable once started',
      body: STOPPED,
      rc: 0,
      expect: { spawnable: true, running: false, cli: 'opencode' },
    },
    {
      name: 'start offered beside an error (another program holds the port): blocked, with the sentence',
      body: status({
        ...INSTALLED,
        actions: ['start', 'remove'],
        error: {
          code: 'port-in-use',
          next: 'other-port',
          message: { text: 'Port {port} is in use by another program.', vars: { port: '11435' } },
        },
      }),
      rc: 1,
      expect: {
        spawnable: false,
        reason: 'blocked',
        errorCode: 'port-in-use',
        message: 'Port 11435 is in use by another program.',
      },
    },
    {
      name: 'not a Mac',
      body: JSON.stringify({
        success: true,
        data: {
          hardware: { platform: 'linux' },
          recommendation: { verdict: 'none', reason: 'not-macos', headline: { text: 'x' } },
          install: { state: 'idle', running: false, actions: ['install'] },
        },
      }),
      rc: 1,
      expect: { spawnable: false, reason: 'not-mac' },
    },
    {
      name: 'nothing installed',
      body: status({ state: 'idle', actions: ['install'] }),
      rc: 1,
      expect: { spawnable: false, reason: 'not-installed' },
    },
    {
      name: 'nothing installed on a Mac that fits none: the reason is the server sentence',
      body: status(
        { state: 'idle', actions: ['install'] },
        {
          verdict: 'none',
          reason: 'memory',
          headline: { text: 'Nothing fits in {budget} GB.', vars: { budget: '12' } },
        }
      ),
      rc: 1,
      expect: {
        spawnable: false,
        reason: 'not-installed',
        message: 'No local model is installed. Nothing fits in 12 GB.',
      },
    },
    {
      name: 'an install that has not finished',
      body: status({ state: 'paused', step: 'model', actions: ['resume', 'install', 'remove'] }),
      rc: 1,
      expect: { spawnable: false, reason: 'install-unfinished', state: 'paused', step: 'model' },
    },
    {
      name: 'admin only in multi-user mode (403)',
      body: JSON.stringify({ success: false, error: 'Admin only in multi-user mode', errorCode: 'FORBIDDEN' }),
      code: '403',
      rc: 1,
      expect: { spawnable: false, reason: 'admin-only' },
    },
    {
      name: 'a Codeman without local model support (404)',
      body: JSON.stringify({ message: 'Route GET:/api/local-model not found', error: 'Not Found', statusCode: 404 }),
      code: '404',
      rc: 1,
      expect: { spawnable: false, reason: 'unsupported' },
    },
    {
      name: 'refused credentials (a plain-text 401)',
      body: 'Unauthorized',
      code: '401',
      rc: 1,
      expect: { spawnable: false, reason: 'unauthorized' },
    },
    {
      name: 'no answer at all',
      body: '',
      code: '000',
      rc: 1,
      expect: { spawnable: false, reason: 'unreachable' },
    },
    {
      name: 'any other failure carries its status and error',
      body: JSON.stringify({ success: false, error: 'boom', errorCode: 'INTERNAL_ERROR' }),
      code: '500',
      rc: 1,
      expect: { spawnable: false, reason: 'error', status: '500', message: 'boom' },
    },
  ];

  for (const c of cases) {
    it(c.name, () => {
      const answers: Record<string, string> = { 'lm-get': c.body };
      if (c.code) answers['lm-get.code'] = c.code;
      const run = runSkill('local_model', answers);
      expect(run.rc).toBe(c.rc);
      expect(run.stdout.trim().split('\n')).toHaveLength(1);
      expect(lastJson(run.stdout)).toMatchObject(c.expect);
      // One read-only GET of the alias path, and nothing else.
      expect(run.calls.map((call) => `${call.m} ${call.key}`)).toEqual(['GET lm-get']);
    });
  }
});

describe.skipIf(!hasJq)('preamble spawn_worker <name> local', () => {
  it('starts a stopped runtime, then quick-starts the harness on the endpoint and waits for its composer', () => {
    const run = runSkill(
      'spawn_worker summ local',
      {
        'lm-get.1': STOPPED,
        'lm-runtime': JSON.stringify({ success: true, data: { state: 'installed', running: false } }),
        'lm-get.2': RUNNING,
        'quick-start': QUICK_START,
        'wait-output': MATCHED,
      },
      // A cloud advisor must never be attached to a worker on the local model.
      { CODEMAN_WORKER_ADVISOR: 'opus' }
    );
    expect(run.stderr).toBe('');
    expect(run.rc).toBe(0);
    expect(run.stdout).toBe(`${SID}\n`);
    expect(run.calls.map((call) => `${call.m} ${call.key}`)).toEqual([
      'GET lm-get',
      'POST lm-runtime',
      'GET lm-get',
      'POST quick-start',
      'GET wait-output',
    ]);
    expect(JSON.parse(run.calls[1].d)).toEqual({ action: 'start' });
    expect(JSON.parse(run.calls[3].d)).toEqual({
      caseName: 'summ',
      mode: 'opencode',
      parentSessionId: SELF,
      customModel: { endpointId: 'local-ollama', modelId: 'qwen3.6:35b-a3b' },
    });
    expect(run.calls[4].q).toContain('match=┃');
    expect(run.calls[4].q).toContain('from=buffer');
  });

  it('does not touch a runtime that already runs', () => {
    const run = runSkill('spawn_worker summ local', {
      'lm-get': RUNNING,
      'quick-start': QUICK_START,
      'wait-output': MATCHED,
    });
    expect(run.rc).toBe(0);
    expect(run.stdout).toBe(`${SID}\n`);
    expect(run.calls.map((call) => call.key)).toEqual(['lm-get', 'quick-start', 'wait-output']);
  });

  for (const answer of [
    { requiresContextWarning: true, modelId: 'qwen3.6:35b-a3b', contextLength: 32768, minSafeContextTokens: 40000 },
    { requiresConfirmation: true, currentlyLoadedModel: 'other', affectedSessions: [{ id: 'x', name: 'w9' }] },
  ]) {
    it(`never confirms on anyone's behalf: ${Object.keys(answer)[0]} fails the spawn with empty stdout`, () => {
      // The route returns these bare; the server's envelope wraps them as success data.
      const run = runSkill('spawn_worker summ local', {
        'lm-get': RUNNING,
        'quick-start': JSON.stringify({ success: true, data: answer }),
      });
      expect(run.rc).toBe(1);
      expect(run.stdout).toBe('');
      expect(run.stderr).toMatch(/wants a person to confirm/);
      expect(run.stderr).toContain(Object.keys(answer)[0]);
      // One quick-start, sent without any confirmation flag, and nothing after it.
      expect(run.calls.map((call) => call.key)).toEqual(['lm-get', 'quick-start']);
      expect(JSON.parse(run.calls[1].d).customModel).toEqual({
        endpointId: 'local-ollama',
        modelId: 'qwen3.6:35b-a3b',
      });
    });
  }

  it('reports a refused launch (the runtime check in quick-start) and spawns nothing', () => {
    const run = runSkill('spawn_worker summ local', {
      'lm-get': RUNNING,
      'quick-start': JSON.stringify({
        success: false,
        error: 'The model on this Mac is not running.',
        errorCode: 'OPERATION_FAILED',
      }),
    });
    expect(run.rc).toBe(1);
    expect(run.stdout).toBe('');
    expect(run.stderr).toContain('OPERATION_FAILED');
    expect(run.calls.map((call) => call.key)).toEqual(['lm-get', 'quick-start']);
  });

  it('refuses before any quick-start when no local model is installed', () => {
    const run = runSkill('spawn_worker summ local', { 'lm-get': status({ state: 'idle', actions: ['install'] }) });
    expect(run.rc).toBe(1);
    expect(run.stdout).toBe('');
    expect(run.stderr).toMatch(/no local model to spawn on \(not-installed\)/);
    expect(run.calls.map((call) => call.key)).toEqual(['lm-get']);
  });

  it('reports a runtime that was started but did not come up, and spawns nothing', () => {
    const failed = status({
      ...INSTALLED,
      actions: ['start', 'remove'],
      error: { code: 'runtime-start-failed', next: 'start', message: { text: 'The runtime did not start.' } },
    });
    const run = runSkill('spawn_worker summ local', {
      'lm-get.1': STOPPED,
      'lm-runtime': JSON.stringify({ success: true, data: { state: 'installed', running: false } }),
      'lm-get.2': failed,
    });
    expect(run.rc).toBe(1);
    expect(run.stdout).toBe('');
    expect(run.stderr).toMatch(/started, but \(blocked\): The runtime did not start\./);
    expect(run.calls.map((call) => call.key)).toEqual(['lm-get', 'lm-runtime', 'lm-get']);
  });

  it('deletes a worker whose composer never drew and hands back nothing', () => {
    const run = runSkill('spawn_worker summ local', {
      'lm-get': RUNNING,
      'quick-start': QUICK_START,
      'wait-output': JSON.stringify({ success: true, data: { wait: { matched: false, timedOut: true } } }),
      delete: JSON.stringify({ success: true, data: {} }),
    });
    expect(run.rc).toBe(1);
    expect(run.stdout).toBe('');
    expect(run.stderr).toMatch(/never drew/);
    expect(run.calls.map((call) => `${call.m} ${call.key}`)).toEqual([
      'GET lm-get',
      'POST quick-start',
      'GET wait-output',
      'DELETE delete',
    ]);
  });

  it('refuses a harness it knows no composer mark for, unless LOCAL_READY_MARK names one', () => {
    const pi = status({ ...INSTALLED, cli: 'pi', running: true, actions: ['start-session', 'stop', 'remove'] });
    const refused = runSkill('spawn_worker summ local', { 'lm-get': pi });
    expect(refused.rc).toBe(1);
    expect(refused.stdout).toBe('');
    expect(refused.stderr).toMatch(/LOCAL_READY_MARK/);
    expect(refused.calls.map((call) => call.key)).toEqual(['lm-get']);

    const marked = runSkill(
      'spawn_worker summ local',
      { 'lm-get': pi, 'quick-start': QUICK_START, 'wait-output': MATCHED },
      { LOCAL_READY_MARK: 'pi-ready' }
    );
    expect(marked.rc).toBe(0);
    expect(marked.stdout).toBe(`${SID}\n`);
    expect(JSON.parse(marked.calls[1].d).mode).toBe('pi');
    expect(marked.calls[2].q).toContain('match=pi-ready');
  });

  it('runs a claude harness through the claude readiness path (hooks vetted, shift+tab)', () => {
    const claude = status({ ...INSTALLED, cli: 'claude', running: true, actions: ['start-session', 'stop', 'remove'] });
    const run = runSkill(
      `mkdir -p "$WD/.claude" && printf '%s' '{"hooks":{"Stop":[{"command":"curl /api/hook-event"}]}}' > "$WD/.claude/settings.local.json"
       printf '%s' "{\\"success\\":true,\\"data\\":{\\"sessionId\\":\\"${SID}\\",\\"casePath\\":\\"$WD\\"}}" > "$ANSWERS/quick-start"
       spawn_worker summ local`,
      { 'lm-get': claude, 'wait-output': MATCHED },
      { CODEMAN_WORKER_ADVISOR: 'opus' }
    );
    expect(run.stderr).toBe('');
    expect(run.rc).toBe(0);
    expect(run.stdout).toBe(`${SID}\n`);
    const body = JSON.parse(run.calls[1].d);
    expect(body.mode).toBe('claude');
    expect(body.advisorModel).toBeUndefined();
    expect(body.customModel).toEqual({ endpointId: 'local-ollama', modelId: 'qwen3.6:35b-a3b' });
    expect(run.calls[2].q).toContain('match=shift+tab');
    // The advisor read-back is skipped too: no GET of the session.
    expect(run.calls.map((call) => call.key)).toEqual(['lm-get', 'quick-start', 'wait-output']);
  });
});

describe.skipIf(!hasJq)('preamble sendmark', () => {
  const delivered = JSON.stringify({
    success: true,
    data: { delivered: true, duplicate: false, wait: { timedOut: true, ended: false, signal: null } },
  });

  /** Answers GET /api/sessions/:id with the run's own working directory, then runs `body`. */
  function withSession(body: string): string {
    return `printf '%s' "{\\"success\\":true,\\"data\\":{\\"id\\":\\"${SID}\\",\\"workingDir\\":\\"$WD\\"}}" > "$ANSWERS/session"; ${body}`;
  }

  it('sends once, waits for the split marker, and returns the answer file', () => {
    const run = runSkill(
      withSession(`sendmark ${SID} $'Summarize these files:\\n- a.md\\n- b.md' 30`),
      { input: delivered, 'wait-output': MATCHED },
      { ANSWER_TEXT: 'a.md: setup. b.md: usage.' }
    );
    expect(run.stderr).toBe('');
    expect(run.rc).toBe(0);
    const out = lastJson(run.stdout);
    expect(out).toMatchObject({
      delivered: true,
      matched: true,
      answer: 'a.md: setup. b.md: usage.',
      truncated: false,
    });
    const token = out.token as string;
    expect(token).toMatch(/^m[0-9a-f]+$/);
    expect(out.answerFile).toBe(join(run.wd, `codeman-answer-${token}.md`));

    expect(run.calls.map((call) => `${call.m} ${call.key}`)).toEqual(['GET session', 'POST input', 'GET wait-output']);
    const input = JSON.parse(run.calls[1].d) as Record<string, unknown>;
    // The exactly-once body: the per-worker clientId, an epoch-second seq, one Enter at the end.
    expect(input.clientId).toBe(`codeman-agent-1-${SID}`);
    expect(typeof input.seq).toBe('number');
    expect(input).toMatchObject({ useMux: true, wait: 'exit', waitTimeout: 1000 });
    const text = input.input as string;
    expect(text.endsWith('\r')).toBe(true);
    expect(text.slice(0, -1)).not.toMatch(/[\r\n]/);
    expect(text.startsWith('Summarize these files: - a.md - b.md (When you are done')).toBe(true);
    expect(text).toContain(`codeman-answer-${token}.md`);
    expect(text).toContain(`the word DONE immediately followed by _${token}`);
    // Split: the typed prompt never holds the joined marker, so its echo cannot match.
    expect(text).not.toContain(`DONE_${token}`);
    expect(run.calls[2].q).toContain(`match=DONE_${token}`);
    expect(run.calls[2].q).toContain('from=buffer');
  });

  it('answers 2 when no marker prints before the timeout, and deletes nothing', () => {
    const run = runSkill(withSession(`sendmark ${SID} 'count to three' 1`), {
      input: delivered,
      'wait-output': NOT_MATCHED,
      'wait-output.delay': '1',
    });
    expect(run.rc).toBe(2);
    expect(lastJson(run.stdout)).toMatchObject({ delivered: true, matched: false, answer: null });
    expect(run.calls.some((call) => call.key === 'delete')).toBe(false);
  });

  it('answers 4 when the marker printed but no answer file turned up', () => {
    const run = runSkill(
      withSession(`sendmark ${SID} 'count to three' 30`),
      { input: delivered, 'wait-output': MATCHED },
      { SENDMARK_FILE_WAIT: '0' }
    );
    expect(run.rc).toBe(4);
    expect(lastJson(run.stdout)).toMatchObject({ matched: true, answer: null });
  });

  it('refuses to read an answer file that is a symlink', () => {
    const secret = join(tmpdir(), 'codeman-sendmark-not-read');
    const run = runSkill(
      withSession(
        `printf 'private' > "${secret}"; sendmark ${SID} 'count to three' 30; rc=$?; rm -f "${secret}"; exit $rc`
      ),
      { input: delivered, 'wait-output': MATCHED },
      { ANSWER_SYMLINK: secret, SENDMARK_FILE_WAIT: '0' }
    );
    expect(run.rc).toBe(4);
    expect(run.stderr).toMatch(/is a symlink, not read/);
    expect(run.stdout).not.toContain('private');
    expect(lastJson(run.stdout)).toMatchObject({ matched: true, answer: null });
  });

  it('answers 3 when the pane did not take the prompt because the worker ended', () => {
    const run = runSkill(withSession(`sendmark ${SID} 'count to three' 30`), {
      input: JSON.stringify({
        success: true,
        data: { delivered: false, duplicate: false, wait: { ended: true, aborted: false } },
      }),
    });
    expect(run.rc).toBe(3);
    expect(lastJson(run.stdout)).toMatchObject({ delivered: false, matched: false });
    expect(run.calls.map((call) => call.key)).toEqual(['session', 'input']);
  });

  it('answers 3 when the worker ends while it waits for the marker', () => {
    const run = runSkill(withSession(`sendmark ${SID} 'count to three' 30`), {
      input: delivered,
      'wait-output': JSON.stringify({
        success: true,
        data: { wait: { matched: false, timedOut: false, ended: true } },
      }),
    });
    expect(run.rc).toBe(3);
    expect(lastJson(run.stdout)).toMatchObject({ matched: false, ended: true });
  });

  it('with SENDMARK_ANSWER_FILE=0 asks for the marker alone and reads no session', () => {
    const run = runSkill(
      `sendmark ${SID} 'review this' 30`,
      { input: delivered, 'wait-output': MATCHED },
      { SENDMARK_ANSWER_FILE: '0' }
    );
    expect(run.rc).toBe(0);
    expect(lastJson(run.stdout)).toMatchObject({ matched: true, answerFile: null, answer: null });
    expect(run.calls.map((call) => call.key)).toEqual(['input', 'wait-output']);
    const text = (JSON.parse(run.calls[0].d) as { input: string }).input;
    expect(text).not.toContain('codeman-answer-');
    expect(text).toContain('the word DONE immediately followed by _');
  });

  it('refuses an empty prompt before sending anything', () => {
    const run = runSkill(withSession(`sendmark ${SID} $'  \\n\\t\\n'`));
    expect(run.rc).toBe(1);
    expect(run.stderr).toMatch(/sendmark: empty prompt/);
    expect(run.calls).toEqual([]);
  });
});