gate-transition.test.ts

import { describe, expect, it } from 'vitest';
import {
  approvalIntentSignature,
  evaluateProductionOperation,
  nextAllowedProductionOperations,
  projectApprovalIntent,
  resolveGateTransition,
} from '../src/gates/index.js';

describe('resolveGateTransition', () => {
  it('turns a visual-only draft revision into one bounded edit without another gate', () => {
    const result = resolveGateTransition({
      line: 'compose',
      artifact: 'composition',
      gate: 'gate_d',
      decision: 'revise',
      scope: 'visual_only',
      recovery: 'not_available',
    });
    expect(result).toMatchObject({ next_action: 'edit_current_cycle', form: null });
    expect(result.allowed_ops).toContain('ovs snapshot');
    expect(result.prohibited_ops).toContain('emit_form');
  });

  it('uses one Gate B amendment and ignores recovery from the old signature', () => {
    const result = resolveGateTransition({
      line: 'compose',
      artifact: 'composition',
      gate: 'preview',
      decision: 'revise',
      scope: 'gate_b_payload',
      recovery: 'available',
    });
    expect(result).toMatchObject({
      next_action: 'open_gate_b_amendment',
      form: { fields: ['gate_b_decision'] },
    });
    expect(result.prohibited_ops).toContain('reset_visual_qa_cycle');
    expect(result.reason).toContain('production-plan payload');
    expect(result.reason).not.toContain('Gate B payload');
  });

  it('uses the current visual revise decision to start a fresh automatic QA cycle', () => {
    const result = resolveGateTransition({
      line: 'compose',
      artifact: 'composition',
      gate: 'preview',
      decision: 'revise',
      scope: 'visual_only',
      recovery: 'available',
    });
    expect(result).toMatchObject({
      next_action: 'edit_and_restart_visual_qa',
      form: null,
      authorities: ['edit_current_artifact', 'restart_visual_qa_cycle'],
    });
    expect(result.allowed_ops).toContain('ovs draft');
    expect(result.prohibited_ops).toContain('emit_form');
    expect(result.reason).toContain('visual-preview or final-video revision');
  });

  it('does not treat an authorization error as proof that recovery is available', () => {
    const result = resolveGateTransition({
      line: 'compose',
      artifact: 'composition',
      gate: 'gate_d',
      decision: 'revise',
      scope: 'visual_only',
      recovery: 'unknown',
      errorCode: 'E_VISUAL_REVISION_EXPLICIT_AUTHORIZATION_REQUIRED',
    });
    expect(result).toMatchObject({ next_action: 'query_status', form: null });
    expect(result.prohibited_ops).toContain('emit_form');
  });

  it('turns an exhausted QA cycle into a user fork, not a silent wait', () => {
    const result = resolveGateTransition({
      line: 'compose',
      artifact: 'composition',
      recovery: 'available',
      errorCode: 'E_VISUAL_REVISION_EXPLICIT_AUTHORIZATION_REQUIRED',
    });
    expect(result).toMatchObject({ next_action: 'present_findings_and_ask_user_direction', form: null });
    expect(result.prohibited_ops).toContain('emit_form');
    expect(result.prohibited_ops).toContain('edit_files');
    expect(result.prohibited_ops).toContain('restart_visual_qa_cycle');
    expect(result.reason).toMatch(/materially different edit/i);
  });

  it('offers the fork on bare exhausted recovery with no decision at all', () => {
    const result = resolveGateTransition({
      line: 'compose',
      artifact: 'composition',
      recovery: 'available',
    });
    expect(result).toMatchObject({ next_action: 'present_findings_and_ask_user_direction', form: null });
    expect(result.reason).toMatch(/waive|skipping/i);
  });

  it('applies a user-dictated amendment directly instead of re-confirming it', () => {
    const result = resolveGateTransition({
      line: 'compose',
      artifact: 'composition',
      gate: 'gate_b',
      decision: 'revise',
      scope: 'gate_b_payload',
      origin: 'user',
    });
    expect(result).toMatchObject({ next_action: 'apply_user_instruction_then_approve_plan', form: null });
    expect(result.authorities).toContain('approve_gate_b');
    expect(result.reason).toMatch(/own words/i);
  });

  it('keeps the Gate B amendment for model-initiated or mixed changes', () => {
    for (const origin of ['model', 'unknown'] as const) {
      const result = resolveGateTransition({
        line: 'compose',
        artifact: 'composition',
        gate: 'gate_b',
        decision: 'revise',
        scope: 'gate_b_payload',
        origin,
      });
      expect(result.next_action).toBe('open_gate_b_amendment');
    }
  });

  it('rejects mixed current and legacy decision fields', () => {
    expect(() => resolveGateTransition({
      line: 'compose',
      artifact: 'composition',
      gate: 'preview',
      decision: 'revise',
      scope: 'visual_only',
      recovery: 'available',
      recoveryDecision: 'new_visual_revision',
    })).toThrow(/cannot both describe the current turn/i);
  });

  it('consumes a legacy recovery decision without emitting another form', () => {
    const result = resolveGateTransition({
      line: 'compose',
      artifact: 'composition',
      recovery: 'available',
      recoveryDecision: 'new_visual_revision',
    });
    expect(result).toMatchObject({ next_action: 'edit_for_fresh_visual_qa', form: null });
    expect(result.allowed_ops).toContain('ovs draft');
    expect(result.prohibited_ops).toContain('emit_form');
  });

  it('continues from an existing approval for an unchanged artifact', () => {
    const result = resolveGateTransition({
      line: 'edit',
      artifact: 'production',
      gate: 'gate_b',
      artifactState: 'unchanged',
      approvalStatus: 'approved',
      recovery: 'not_available',
    });
    expect(result).toMatchObject({ next_action: 'continue_from_existing_approval', form: null });
    expect(result.prohibited_ops).toContain('emit_form');
  });

  it('maps an explicit preview approval to the real OVS draft operation', () => {
    const result = resolveGateTransition({
      line: 'compose',
      artifact: 'composition',
      gate: 'preview',
      decision: 'approve',
      scope: 'none',
      recovery: 'not_available',
    });
    expect(result).toMatchObject({ next_action: 'render_approved_preview', allowed_ops: ['ovs draft'] });
  });

  it('lets a current Gate B amendment approval win over cached approval', () => {
    const result = resolveGateTransition({
      line: 'compose',
      artifact: 'composition',
      gate: 'gate_b',
      decision: 'approve',
      scope: 'gate_b_payload',
      recovery: 'not_available',
      artifactState: 'unchanged',
      approvalStatus: 'approved',
    });
    expect(result).toMatchObject({
      next_action: 'apply_approved_amendment_then_approve_plan',
      authorities: ['edit_current_artifact', 'approve_gate_b'],
      form: null,
    });
    expect(result.prohibited_ops).toContain('emit_form');
  });
});

describe('approval intent identity', () => {
  it('separates execution and catalog metadata from stable production intent', () => {
    const base = {
      segments: [{
        id: 'shot-1',
        prompt: 'A red product on a stone pedestal',
        status: 'planned',
        produced_path: 'outputs/old.mp4',
      }],
      tracks: {
        narration: {
          synthesis: {
            route_ref: 'openai-compatible',
            voice: 'nova',
            display_name: 'Nova (old label)',
            provider_label: 'Provider A',
            language: 'en-US',
            speed: 1,
          },
        },
      },
      _runtime: { cache_dir: '/tmp/a' },
    };
    const refreshed = structuredClone(base);
    refreshed.segments[0].status = 'complete';
    refreshed.segments[0].produced_path = 'outputs/new.mp4';
    refreshed.tracks.narration.synthesis.display_name = 'Nova';
    refreshed.tracks.narration.synthesis.provider_label = 'Provider B';
    refreshed._runtime.cache_dir = '/tmp/b';
    expect(projectApprovalIntent(refreshed)).toEqual(projectApprovalIntent(base));
    expect(approvalIntentSignature(refreshed)).toBe(approvalIntentSignature(base));

    refreshed.segments[0].prompt = 'A blue product on a stone pedestal';
    expect(approvalIntentSignature(refreshed)).not.toBe(approvalIntentSignature(base));
  });

  it('does not ignore display_name outside a stable voice selection', () => {
    expect(approvalIntentSignature({ display_name: 'First' }))
      .not.toBe(approvalIntentSignature({ display_name: 'Second' }));
  });
});

describe('fact-based production admission', () => {
  it('keeps visual preview and repair available while narration is recovering', () => {
    const facts = {
      planApproved: true,
      narrationRequired: true,
      narrationMaterialized: false,
    };
    expect(evaluateProductionOperation('composition.snapshot', facts)).toEqual({ ok: true });
    expect(evaluateProductionOperation('composition.approve_preview', facts)).toEqual({ ok: true });
    expect(evaluateProductionOperation('composition.draft', facts)).toMatchObject({
      ok: false,
      errorCode: 'E_NARRATION_MATERIALIZATION_REQUIRED',
    });
    expect(nextAllowedProductionOperations(facts)).toContain('composition.snapshot');
    expect(nextAllowedProductionOperations(facts)).not.toContain('composition.export');
  });

  it('requires current Gate B approval without consulting a compatibility stage', () => {
    expect(evaluateProductionOperation('composition.prepare', {
      planApproved: false,
      narrationRequired: false,
      narrationMaterialized: false,
    })).toMatchObject({
      ok: false,
      errorCode: 'E_GATE_B_APPROVAL_REQUIRED',
    });
  });
});