O seguinte funciona, mas provavelmente há uma versão mais inteligente. Explicação da lógica da consulta:

Primeiro descobrimos quantas "reinicializações" foram feitas até e incluindo a linha atual contando os não nulos da reset_valcoluna, para que possamos separar as linhas em subgrupos.

Também usamos outra função de janela LAST_VALUE()com IGNORE NULLS, para que possamos encontrar a última reset_value.

Observe que ambas as funções de janela COUNT()e LAST_VALUE()têm um ORDER BY, portanto, a janela padrão ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW. Omitido na consulta, para deixar o código mais claro.

Assumindo que valnão é anulável, a outra função de janela também pode ser encurtada, de:

       COALESCE(SUM(val) OVER 
         (PARTITION BY group_id, reset_count 
          ORDER BY order_val 
          ROWS BETWEEN UNBOUNDED PRECEDING 
                   AND 1 PRECEDING), 0)   

(evitando o COALESCE()também) para:

       SUM(val) OVER 
         (PARTITION BY group_id, reset_count 
          ORDER BY order_val)
       - val

Finalmente, no segundo cte, usamos os subgrupos encontrados acima (usando PARTITION BY group_id, reset_count) para encontrar as somas cumulativas.

WITH x AS
  ( SELECT temp.*, 
           COUNT(reset_val) OVER 
               (PARTITION BY group_id 
                ORDER BY order_val)
             AS reset_count,
           COALESCE(LAST_VALUE(reset_val IGNORE NULLS) OVER 
               (PARTITION BY group_id 
                ORDER BY order_val), 0)
             AS reset_value
    FROM temp
  ) ,
y AS 
  ( SELECT x.*,
           COALESCE(SUM(val) OVER 
             (PARTITION BY group_id, reset_count 
              ORDER BY order_val 
              ROWS BETWEEN UNBOUNDED PRECEDING 
                       AND 1 PRECEDING), 0)            
           + reset_value AS cumsum      
    FROM x
  )
SELECT *
FROM y ;

Teste no SQLfiddle .

Outra variação, baseada na resposta recursiva de @Chris . (ligeiramente melhorado, trabalha com não consecutivos order_val, evita o final GROUP BY).
Também funciona caso a primeira linha de um grupo tenha reset_val:

WITH row_nums AS
  ( SELECT id, group_id, order_val, reset_val, val, 
           ROW_NUMBER() OVER (PARTITION BY group_id
                              ORDER BY order_val)
             AS rn
    FROM temp
  ) ,
updated_temp (id, group_id, order_val, reset_val, val, rn, cumsum) AS
  ( SELECT id, group_id, order_val, reset_val, val, rn, 
           COALESCE(reset_val, 0)
    FROM row_nums
    WHERE rn = 1
  UNION ALL
    SELECT curr.id, curr.group_id, curr.order_val, curr.reset_val, curr.val, curr.rn, 
           COALESCE(curr.reset_val, prev.val + prev.cumsum) 
    FROM row_nums  curr 
      JOIN updated_temp  prev 
        ON  curr.rn-1 = prev.rn 
        AND curr.group_id = prev.group_id
  )
SELECT id, group_id, order_val, reset_val, val, cumsum
FROM updated_temp
ORDER BY group_id, order_val ;

Teste no SQLfiddle-2 .

Mais uma variação, usando a CONNECT BYsintaxe mais antiga (proprietária) para consultas recursivas. Mais compacto, mas acho mais difícil de escrever e ler do que a versão CTE:

WITH row_nums AS
  ( SELECT id, group_id, order_val, reset_val, val, 
           ROW_NUMBER() OVER (PARTITION BY group_id
                              ORDER BY order_val)
             AS rn,
           COALESCE(reset_val, 0) AS cumsum
    FROM temp
  ) 
SELECT id, group_id, order_val, reset_val, val, rn,  
       COALESCE(reset_val, PRIOR val + PRIOR cumsum, 0) AS cumsum
FROM row_nums
START WITH rn = 1 OR reset_val IS NOT NULL
CONNECT BY  rn-1 = PRIOR rn 
        AND group_id = PRIOR group_id
        AND reset_val IS NULL 
ORDER BY group_id, order_val ; 

Testado em SQLfiddle-3 .

Como exercício acadêmico, implementei uma solução em Postgres. Agora, eu sei que era uma pergunta sobre Oracle, mas também foi enquadrada como uma pergunta de SQL! :) Se alguém estiver mais familiarizado com a sintaxe de consulta recursiva do Oracle, talvez encontre as alterações necessárias para fazer isso rodar no Oracle.

Consulta recursiva (no Postgres)

Nesta solução, faço uso de consultas recursivas, aplicando a sintaxe do Postgres WITH RECURSIVEno meu CTE. A consulta recursiva é a seguinte:

WITH RECURSIVE updated_temp AS (
  SELECT temp.*, 0::numeric AS CUMSUM FROM temp
  UNION
  SELECT curr.id, curr.group_id, curr.order_val, curr.reset_val, curr.val, 
  COALESCE(curr.RESET_VAL,prev.VAL + prev.CUMSUM) AS CUMSUM
  FROM temp AS curr JOIN updated_temp AS prev 
  ON curr.ORDER_VAL-1 = prev.ORDER_VAL AND curr.group_id = prev.group_id)
SELECT id, group_id, order_val, reset_val, val, max(cumsum) FROM updated_temp 
GROUP BY id, group_id, order_val, reset_val, val ORDER BY id ASC;

Aqui está o SQL Fiddle correspondente .

Obviamente, a chave para o comportamento adequado dessa consulta é primeiro usar a parte recursiva da consulta para criar sua soma cumulativa, certificando-se de usar COALESCEpara substituir em qualquer um RESET_VALque determine o valor CUMSUMda linha. O último SELECTsimplesmente faz com que você filtre pelo valor máximo do CUMSUMporque se a consulta foi construída corretamente, o máximo é idêntico à soma cumulativa.

Editar: versão Oracle da consulta recursiva

Esta tradução para Oracle foi fornecida pelo ypercube :

WITH updated_temp (id, group_id, order_val, reset_val, val, cumsum) 
AS (
  SELECT id, group_id, order_val, reset_val, val, 0 
  FROM temp
  UNION ALL
  SELECT curr.id, curr.group_id, curr.order_val, curr.reset_val, curr.val, 
     COALESCE(curr.reset_val, prev.val + prev.cumsum) 
  FROM temp  curr 
    JOIN updated_temp  prev 
      ON  curr.order_val-1 = prev.order_val 
      AND curr.group_id = prev.group_id
)
  SELECT id, group_id, order_val, reset_val, val, max(cumsum) 
  FROM updated_temp 
  GROUP BY id, group_id, order_val, reset_val, val 
  ORDER BY id ASC;

Oracle SQLFiddle