@robota-sdk/agent-transport 3.0.0-beta.78 → 3.0.0-beta.81

package/src/__tests__/programmatic/programmatic-flows.test.ts

@@ -1,140 +0,0 @@
-/**
- * TEST-009 Phase 2: conversation + slash-command flows driven through `IAgentDriver`.
- *
- * Exercises the in-process driver (`createProgrammaticAgent`) against the REAL framework loop with the
- * scripted provider: multi-turn context, a slash command producing a `command-result`, and the CMD-004
- * ask seam (a command self-asks via `getUserInteraction()`, pre-answered through `queueUserAction`).
- * All assertions read the shared `InteractionEvent` stream the contract exposes.
- */
-
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { confirmAction, isConfirmed } from '@robota-sdk/agent-core';
-import { createScriptedProvider } from '@robota-sdk/agent-core/testing';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-
-import { createProgrammaticAgent } from '../../programmatic/index.js';
-
-import type { ICommandModule } from '@robota-sdk/agent-framework';
-import type { IAgentDriver, InteractionEvent } from '@robota-sdk/agent-interface-transport';
-
-function commandResults(
-  events: readonly InteractionEvent[],
-): Array<{ name: string; output: string }> {
-  return events
-    .filter(
-      (e): e is Extract<InteractionEvent, { type: 'command-result' }> =>
-        e.type === 'command-result',
-    )
-    .map((e) => ({ name: e.name, output: e.output }));
-}
-
-/** A read-only `/ping` command that returns a fixed result — no host adapters needed. */
-const PING_MODULE: ICommandModule = {
-  name: 'ping',
-  systemCommands: [
-    {
-      name: 'ping',
-      description: 'test ping',
-      userInvocable: true,
-      safety: 'read-only',
-      requiresPermission: false,
-      execute: () => ({ message: 'PONG', success: true }),
-    },
-  ],
-};
-
-/** A `/danger` command that self-asks for confirmation via the CMD-004 ask seam. */
-const CONFIRM_MODULE: ICommandModule = {
-  name: 'danger',
-  systemCommands: [
-    {
-      name: 'danger',
-      description: 'requires confirmation',
-      userInvocable: true,
-      safety: 'read-only',
-      requiresPermission: false,
-      lifecycle: 'inline',
-      execute: async (context) => {
-        const ui = context.getUserInteraction?.();
-        const response = ui ? await ui.ask(confirmAction('danger', 'Are you sure?')) : undefined;
-        if (!response || !isConfirmed(response)) {
-          return { message: 'DANGER_CANCELLED', success: true };
-        }
-        return { message: 'DANGER_RAN', success: true };
-      },
-    },
-  ],
-};
-
-describe('IAgentDriver conversation + slash flows (TEST-009 Phase 2)', () => {
-  let cwd: string;
-  let driver: IAgentDriver | undefined;
-
-  beforeEach(() => {
-    cwd = mkdtempSync(join(tmpdir(), 'robota-flows-'));
-  });
-  afterEach(async () => {
-    await driver?.stop();
-    driver = undefined;
-    rmSync(cwd, { recursive: true, force: true });
-  });
-
-  it('carries multi-turn conversation context across sends', async () => {
-    const scripted = createScriptedProvider([{ text: 'NOTED_42' }, { text: 'IT_WAS_42' }]);
-    driver = createProgrammaticAgent({ provider: scripted.provider, cwd });
-    await driver.start();
-
-    await driver.send('Remember the number 42');
-    expect(driver.lastAssistantText()).toBe('NOTED_42');
-
-    await driver.send('What number?');
-    expect(driver.lastAssistantText()).toBe('IT_WAS_42');
-    expect(driver.assistantReplies()).toEqual(['NOTED_42', 'IT_WAS_42']);
-
-    // The second request must carry the prior turn (real session context).
-    const second = (scripted.requests[1] ?? []).map((m) => String(m.content)).join('\n');
-    expect(second).toContain('Remember the number 42');
-    expect(second).toContain('NOTED_42');
-  });
-
-  it('runs a slash command and surfaces a command-result event', async () => {
-    const scripted = createScriptedProvider([{ text: 'unused' }]);
-    driver = createProgrammaticAgent({
-      provider: scripted.provider,
-      cwd,
-      commandModules: [PING_MODULE],
-    });
-    await driver.start();
-
-    await driver.send('/ping');
-    expect(commandResults(driver.events)).toEqual([{ name: 'ping', output: 'PONG' }]);
-  });
-
-  it('drives the ask seam: queueUserAction confirms a self-asking command; empty queue cancels it', async () => {
-    const scripted = createScriptedProvider([{ text: 'unused' }, { text: 'unused' }]);
-    driver = createProgrammaticAgent({
-      provider: scripted.provider,
-      cwd,
-      commandModules: [CONFIRM_MODULE],
-    });
-    await driver.start();
-
-    // Confirmed → the command runs (askUser resolved from the pre-supplied queue).
-    driver.queueUserAction({ type: 'answer', values: ['yes'] });
-    await driver.send('/danger');
-    const ranAfterConfirm = commandResults(driver.events).filter(
-      (c) => c.output === 'DANGER_RAN',
-    ).length;
-    expect(ranAfterConfirm).toBe(1);
-
-    // Empty queue → askUser resolves `cancelled` → the command takes its cancel path (does NOT run).
-    await driver.send('/danger');
-    expect(commandResults(driver.events).filter((c) => c.output === 'DANGER_RAN').length).toBe(
-      ranAfterConfirm,
-    );
-    expect(commandResults(driver.events).some((c) => c.output === 'DANGER_CANCELLED')).toBe(true);
-  });
-});

package/src/__tests__/transport-registry.stop-all.test.ts

@@ -1,53 +0,0 @@
-import { mkdtempSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-
-import { describe, expect, it, vi } from 'vitest';
-
-import { TransportRegistry } from '../transport-registry';
-
-import type { IInteractiveSession } from '@robota-sdk/agent-interface-transport';
-import type { IConfigurableTransport } from '@robota-sdk/agent-interface-transport';
-
-function makeTransport(
-  name: string,
-  stop: () => Promise<void>,
-): IConfigurableTransport<IInteractiveSession> {
-  return {
-    name,
-    defaultEnabled: true,
-    attach: vi.fn(),
-    start: vi.fn().mockResolvedValue(undefined),
-    stop,
-  } as unknown as IConfigurableTransport<IInteractiveSession>;
-}
-
-describe('TransportRegistry.stopAll (best-effort, CORE-013)', () => {
-  it('stops every transport even when one stop fails, and collects the error', async () => {
-    const registry = new TransportRegistry(
-      path.join(mkdtempSync(path.join(tmpdir(), 'registry-')), 'settings.json'),
-    );
-    const stoppedSecond = vi.fn().mockResolvedValue(undefined);
-    registry.register(
-      makeTransport('failing', async () => {
-        throw new Error('stop boom');
-      }),
-    );
-    registry.register(makeTransport('healthy', stoppedSecond));
-
-    const result = await registry.stopAll();
-
-    expect(stoppedSecond).toHaveBeenCalledTimes(1);
-    expect(result.errors).toHaveLength(1);
-    expect(result.errors[0].message).toBe('stop boom');
-  });
-
-  it('returns an empty error list when all stops succeed', async () => {
-    const registry = new TransportRegistry(
-      path.join(mkdtempSync(path.join(tmpdir(), 'registry-')), 'settings.json'),
-    );
-    registry.register(makeTransport('a', vi.fn().mockResolvedValue(undefined)));
-
-    await expect(registry.stopAll()).resolves.toEqual({ errors: [] });
-  });
-});

package/src/headless/HeadlessInteractionChannel.ts

@@ -1,129 +0,0 @@
-/**
- * HeadlessInteractionChannel — owns session lifecycle for non-interactive (print) mode.
- *
- * Mirrors TuiInteractionChannel's ownership pattern: session creation lives here,
- * not in the caller. print-mode.ts constructs this and calls run().
- */
-
-import { execSync } from 'node:child_process';
-
-import { InteractiveSession } from '@robota-sdk/agent-framework';
-
-import { createHeadlessRunner, type TOutputFormat } from './headless-runner.js';
-
-import type { IAIProvider, TPermissionMode } from '@robota-sdk/agent-core';
-import type {
-  IBackgroundTaskRunner,
-  ICommandHostAdapters,
-  ICommandModule,
-  TSubagentRunnerFactory,
-  TShellExecFn,
-} from '@robota-sdk/agent-framework';
-import type { IInteractiveSessionStore } from '@robota-sdk/agent-interface-transport';
-
-export interface IHeadlessInteractionChannelOptions {
-  cwd: string;
-  provider: IAIProvider;
-  outputFormat: TOutputFormat;
-  permissionMode?: TPermissionMode;
-  maxTurns?: number;
-  sessionStore?: IInteractiveSessionStore;
-  /** Continue/resume an existing session by id (print-mode parity with TUI). */
-  resumeSessionId?: string;
-  /** Fork the resumed session into a new independent session instead of appending. */
-  forkSession?: boolean;
-  sessionName?: string;
-  bare?: boolean;
-  allowedTools?: string[];
-  deniedTools?: string[];
-  appendSystemPrompt?: string;
-  systemPrompt?: string;
-  /** Name reported to the underlying agent config (resolved by the CLI, e.g. preset agentName). */
-  agentName?: string;
-  /** Active preset id selected at startup (PRESET-011 runtime state). Defaults to 'default'. */
-  activePresetId?: string;
-  /** Preset persona block composed as a `source: 'persona'` system-prompt section (priority 5). */
-  persona?: string;
-  /** Preset execution capability: activate agent runtime + subagent/background dispatch. */
-  enableParallelSubagents?: boolean;
-  /** Preset execution capability: run a post-task self-verification step. */
-  selfVerification?: boolean;
-  backgroundTaskRunners?: IBackgroundTaskRunner[];
-  subagentRunnerFactory?: TSubagentRunnerFactory;
-  commandModules?: readonly ICommandModule[];
-  commandHostAdapters?: ICommandHostAdapters;
-  shellExec?: TShellExecFn;
-}
-
-export class HeadlessInteractionChannel {
-  private readonly opts: IHeadlessInteractionChannelOptions;
-  private exitCode = 0;
-
-  constructor(options: IHeadlessInteractionChannelOptions) {
-    this.opts = options;
-  }
-
-  async run(prompt: string): Promise<void> {
-    const session = this.createSession();
-    const runner = createHeadlessRunner({ session, outputFormat: this.opts.outputFormat });
-    this.exitCode = await runner.run(prompt);
-    await session.shutdown({ reason: 'prompt_input_exit', message: 'Headless transport complete' });
-  }
-
-  /**
-   * GOAL-001: run an autonomous goal to completion (or a stop condition) in headless mode.
-   * Mirrors {@link run} but drives the framework goal loop instead of a single prompt.
-   */
-  async runGoal(objective: string, options: { maxIterations?: number } = {}): Promise<void> {
-    const session = this.createSession();
-    const runner = createHeadlessRunner({ session, outputFormat: this.opts.outputFormat });
-    this.exitCode = await runner.runGoal(objective, options);
-    await session.shutdown({ reason: 'prompt_input_exit', message: 'Headless goal complete' });
-  }
-
-  private createSession(): InteractiveSession {
-    const shellExec: TShellExecFn =
-      this.opts.shellExec ??
-      ((command: string) =>
-        execSync(command, { timeout: 5000, encoding: 'utf-8', stdio: 'pipe' }).trimEnd());
-
-    return new InteractiveSession({
-      cwd: this.opts.cwd,
-      provider: this.opts.provider,
-      permissionMode: this.opts.permissionMode ?? 'bypassPermissions',
-      // CMD-004: headless has no interactive renderer, so it injects no askHandler — the session's
-      // getUserInteraction() returns undefined and each command applies its explicit no-human path
-      // (e.g. /mode reports current, /exit and /clear proceed — never a silent guess).
-      maxTurns: this.opts.maxTurns,
-      sessionStore: this.opts.sessionStore,
-      resumeSessionId: this.opts.resumeSessionId,
-      forkSession: this.opts.forkSession,
-      sessionName: this.opts.sessionName,
-      bare: this.opts.bare || undefined,
-      allowedTools: this.opts.allowedTools,
-      deniedTools: this.opts.deniedTools,
-      appendSystemPrompt: this.opts.appendSystemPrompt,
-      ...(this.opts.persona !== undefined ? { persona: this.opts.persona } : {}),
-      ...(this.opts.systemPrompt ? { systemPrompt: this.opts.systemPrompt } : {}),
-      backgroundTaskRunners: this.opts.backgroundTaskRunners,
-      subagentRunnerFactory: this.opts.subagentRunnerFactory,
-      commandModules: this.opts.commandModules,
-      commandHostAdapters: this.opts.commandHostAdapters,
-      shellExec,
-      agentName: this.opts.agentName,
-      ...(this.opts.activePresetId !== undefined
-        ? { activePresetId: this.opts.activePresetId }
-        : {}),
-      ...(this.opts.enableParallelSubagents !== undefined
-        ? { enableParallelSubagents: this.opts.enableParallelSubagents }
-        : {}),
-      ...(this.opts.selfVerification !== undefined
-        ? { selfVerification: this.opts.selfVerification }
-        : {}),
-    });
-  }
-
-  getExitCode(): number {
-    return this.exitCode;
-  }
-}

package/src/headless/__tests__/headless-channel-options.test.ts

@@ -1,106 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type { IAIProvider } from '@robota-sdk/agent-core';
-
-const sessionCtorSpy = vi.fn();
-
-vi.mock('@robota-sdk/agent-framework', async (importOriginal) => {
-  const mod = await importOriginal<typeof import('@robota-sdk/agent-framework')>();
-
-  class FakeInteractiveSession {
-    private readonly listeners = new Map<string, Array<(...args: unknown[]) => void>>();
-
-    constructor(options: unknown) {
-      sessionCtorSpy(options);
-    }
-
-    on(event: string, handler: (...args: unknown[]) => void): void {
-      const list = this.listeners.get(event) ?? [];
-      list.push(handler);
-      this.listeners.set(event, list);
-    }
-
-    off(): void {}
-
-    async submit(): Promise<void> {
-      const result = {
-        response: 'ok',
-        history: [],
-        toolSummaries: [],
-        contextState: {},
-      };
-      for (const handler of this.listeners.get('complete') ?? []) {
-        handler(result);
-      }
-    }
-
-    getSession(): { getSessionId: () => string } {
-      return { getSessionId: () => 'test-session' };
-    }
-
-    async shutdown(): Promise<void> {}
-  }
-
-  return { ...mod, InteractiveSession: FakeInteractiveSession };
-});
-
-import { HeadlessInteractionChannel } from '../HeadlessInteractionChannel.js';
-
-describe('HeadlessInteractionChannel session options', () => {
-  beforeEach(() => {
-    sessionCtorSpy.mockClear();
-  });
-
-  it('TC-01: passes deniedTools through to the InteractiveSession options', async () => {
-    const channel = new HeadlessInteractionChannel({
-      cwd: process.cwd(),
-      provider: {} as IAIProvider,
-      outputFormat: 'text',
-      allowedTools: ['Read'],
-      deniedTools: ['Bash', 'Glob'],
-      shellExec: () => '',
-    });
-    await channel.run('hello');
-    expect(sessionCtorSpy).toHaveBeenCalledTimes(1);
-    const options = sessionCtorSpy.mock.calls[0]?.[0] as {
-      allowedTools?: string[];
-      deniedTools?: string[];
-    };
-    expect(options.allowedTools).toEqual(['Read']);
-    expect(options.deniedTools).toEqual(['Bash', 'Glob']);
-  });
-
-  it('TC-01 (CLI-063): passes resumeSessionId and forkSession through to the InteractiveSession options', async () => {
-    const channel = new HeadlessInteractionChannel({
-      cwd: process.cwd(),
-      provider: {} as IAIProvider,
-      outputFormat: 'text',
-      resumeSessionId: 'session_prior_abc',
-      forkSession: true,
-      shellExec: () => '',
-    });
-    await channel.run('hello');
-    expect(sessionCtorSpy).toHaveBeenCalledTimes(1);
-    const options = sessionCtorSpy.mock.calls[0]?.[0] as {
-      resumeSessionId?: string;
-      forkSession?: boolean;
-    };
-    expect(options.resumeSessionId).toBe('session_prior_abc');
-    expect(options.forkSession).toBe(true);
-  });
-
-  it('TC-01 (CLI-063): omits resume fields when not provided', async () => {
-    const channel = new HeadlessInteractionChannel({
-      cwd: process.cwd(),
-      provider: {} as IAIProvider,
-      outputFormat: 'text',
-      shellExec: () => '',
-    });
-    await channel.run('hello');
-    const options = sessionCtorSpy.mock.calls[0]?.[0] as {
-      resumeSessionId?: string;
-      forkSession?: boolean;
-    };
-    expect(options.resumeSessionId).toBeUndefined();
-    expect(options.forkSession).toBeUndefined();
-  });
-});

package/src/headless/__tests__/headless-goal-runner.test.ts

@@ -1,108 +0,0 @@
-/**
- * GOAL-001: headless autonomous goal runner. A fake session emits goal lifecycle events; the
- * runner resolves to exit 0 when satisfied, GOAL_NOT_SATISFIED_EXIT_CODE at a bound, and 1 on error.
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-import { createHeadlessRunner, GOAL_NOT_SATISFIED_EXIT_CODE } from '../headless-runner.js';
-
-import type {
-  IGoalEvent,
-  IGoalState,
-  IInteractiveSession,
-} from '@robota-sdk/agent-interface-transport';
-
-type TListener = (...args: unknown[]) => void;
-
-function goalState(overrides: Partial<IGoalState> = {}): IGoalState {
-  return {
-    id: 'g1',
-    objective: 'do it',
-    status: 'satisfied',
-    iterations: 2,
-    maxIterations: 25,
-    startedAt: '2026-06-27T00:00:00.000Z',
-    progress: [],
-    ...overrides,
-  };
-}
-
-/** Minimal fake session whose setGoal drives a scripted sequence of events. */
-function createFakeSession(
-  script: (emit: (e: string, ...a: unknown[]) => void) => void,
-): IInteractiveSession {
-  const listeners = new Map<string, Set<TListener>>();
-  const emit = (event: string, ...args: unknown[]): void => {
-    for (const fn of listeners.get(event) ?? []) fn(...args);
-  };
-  return {
-    on: (event: string, handler: TListener) => {
-      if (!listeners.has(event)) listeners.set(event, new Set());
-      listeners.get(event)!.add(handler);
-    },
-    off: (event: string, handler: TListener) => listeners.get(event)?.delete(handler),
-    setGoal: async () => {
-      queueMicrotask(() => script(emit));
-      return goalState();
-    },
-    getSession: () => ({ getSessionId: () => 'sess' }),
-  } as unknown as IInteractiveSession;
-}
-
-const stdoutChunks: string[] = [];
-const stderrChunks: string[] = [];
-
-beforeEach(() => {
-  stdoutChunks.length = 0;
-  stderrChunks.length = 0;
-  vi.spyOn(process.stdout, 'write').mockImplementation(((chunk: unknown) => {
-    stdoutChunks.push(String(chunk));
-    return true;
-  }) as never);
-  vi.spyOn(process.stderr, 'write').mockImplementation(((chunk: unknown) => {
-    stderrChunks.push(String(chunk));
-    return true;
-  }) as never);
-});
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-
-describe('headless runGoal', () => {
-  it('exits 0 and prints turn responses when the goal is satisfied', async () => {
-    const session = createFakeSession((emit) => {
-      emit('complete', { response: 'did step 1' });
-      emit('goal_event', {
-        type: 'goal_started',
-        goal: goalState({ status: 'active' }),
-      } as IGoalEvent);
-      emit('goal_event', {
-        type: 'goal_stopped',
-        goal: goalState({ stopReason: 'satisfied' }),
-      } as IGoalEvent);
-    });
-    const code = await createHeadlessRunner({ session, outputFormat: 'text' }).runGoal('do it');
-    expect(code).toBe(0);
-    expect(stdoutChunks).toContain('did step 1\n');
-    expect(stdoutChunks.join('')).toContain('Goal satisfied');
-  });
-
-  it('exits GOAL_NOT_SATISFIED_EXIT_CODE when stopped at a bound', async () => {
-    const session = createFakeSession((emit) => {
-      emit('goal_event', {
-        type: 'goal_stopped',
-        goal: goalState({ status: 'stopped', stopReason: 'max-iterations' }),
-      } as IGoalEvent);
-    });
-    const code = await createHeadlessRunner({ session, outputFormat: 'text' }).runGoal('do it');
-    expect(code).toBe(GOAL_NOT_SATISFIED_EXIT_CODE);
-  });
-
-  it('exits 1 on a turn error', async () => {
-    const session = createFakeSession((emit) => {
-      emit('error', new Error('provider exploded'));
-    });
-    const code = await createHeadlessRunner({ session, outputFormat: 'text' }).runGoal('do it');
-    expect(code).toBe(1);
-  });
-});

package/src/headless/__tests__/headless-provider-failure.integration.test.ts

@@ -1,143 +0,0 @@
-/**
- * Provider-failure exit-code integration tests (CLI-064).
- *
- * Drives a real InteractiveSession with a provider whose chat() throws (the 401 class
- * observed in product verification) and asserts the headless transport surfaces the
- * failure: non-zero exit code and an error envelope/stderr message — never exit 0.
- */
-
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { InteractiveSession } from '@robota-sdk/agent-framework';
-import { afterEach, describe, expect, it } from 'vitest';
-
-import { createHeadlessTransport } from '../headless-transport.js';
-
-import type { TInteractiveSessionOptions } from '@robota-sdk/agent-framework';
-
-type TStandardSessionOptions = Extract<
-  TInteractiveSessionOptions,
-  { cwd: string; provider: unknown }
->;
-type TTestProvider = TStandardSessionOptions['provider'];
-type TResolvedConfig = NonNullable<TStandardSessionOptions['config']>;
-
-const AUTH_FAILURE_MESSAGE =
-  '401 {"type":"error","error":{"type":"authentication_error","message":"invalid x-api-key"}}';
-
-function createConfig(): TResolvedConfig {
-  return {
-    defaultTrustLevel: 'moderate',
-    language: 'en',
-    provider: {
-      name: 'failing-test-provider',
-      model: 'failing-test-model',
-      apiKey: 'test-key',
-    },
-    permissions: { allow: [], deny: [] },
-    env: {},
-  };
-}
-
-function createAuthFailingProvider(): TTestProvider {
-  return {
-    name: 'failing-test-provider',
-    version: '1.0.0',
-    async chat() {
-      throw new Error(AUTH_FAILURE_MESSAGE);
-    },
-    async generateResponse() {
-      return { content: 'unused' };
-    },
-    supportsTools() {
-      return true;
-    },
-    validateConfig() {
-      return true;
-    },
-  };
-}
-
-function captureStream(stream: NodeJS.WriteStream): { writes: string[]; restore(): void } {
-  const writes: string[] = [];
-  const originalWrite = stream.write;
-  stream.write = ((chunk: string | Uint8Array, encodingOrCallback?: unknown) => {
-    writes.push(typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf8'));
-    if (typeof encodingOrCallback === 'function') {
-      encodingOrCallback();
-    }
-    return true;
-  }) as typeof stream.write;
-  return {
-    writes,
-    restore() {
-      stream.write = originalWrite;
-    },
-  };
-}
-
-describe('headless provider failure exit codes (CLI-064)', () => {
-  let cwd: string | undefined;
-
-  afterEach(() => {
-    if (cwd) rmSync(cwd, { recursive: true, force: true });
-    cwd = undefined;
-  });
-
-  it('TC-02: text format exits 1 and writes the auth failure to stderr', async () => {
-    cwd = mkdtempSync(join(tmpdir(), 'robota-headless-fail-'));
-    const session = new InteractiveSession({
-      cwd,
-      provider: createAuthFailingProvider(),
-      config: createConfig(),
-      permissionMode: 'bypassPermissions',
-      bare: true,
-    });
-    const stdout = captureStream(process.stdout);
-    const stderr = captureStream(process.stderr);
-
-    try {
-      const transport = createHeadlessTransport({ outputFormat: 'text', prompt: 'say hi' });
-      session.attachTransport(transport);
-      await transport.start();
-
-      expect(transport.getExitCode()).toBe(1);
-      expect(stderr.writes.join('')).toContain('authentication_error');
-    } finally {
-      stdout.restore();
-      stderr.restore();
-    }
-  });
-
-  it('TC-02: json format exits 1 with subtype error and error_code api_error', async () => {
-    cwd = mkdtempSync(join(tmpdir(), 'robota-headless-fail-'));
-    const session = new InteractiveSession({
-      cwd,
-      provider: createAuthFailingProvider(),
-      config: createConfig(),
-      permissionMode: 'bypassPermissions',
-      bare: true,
-    });
-    const stdout = captureStream(process.stdout);
-    const stderr = captureStream(process.stderr);
-
-    try {
-      const transport = createHeadlessTransport({ outputFormat: 'json', prompt: 'say hi' });
-      session.attachTransport(transport);
-      await transport.start();
-
-      expect(transport.getExitCode()).toBe(1);
-      const parsed: unknown = JSON.parse(stdout.writes.join('').trim());
-      expect(parsed).toMatchObject({
-        type: 'result',
-        subtype: 'error',
-        error_code: 'api_error',
-      });
-    } finally {
-      stdout.restore();
-      stderr.restore();
-    }
-  });
-});