internal/intg/template_test.go (1)

223-226: ⚡ Quick win

Assert the closing code fence too to tighten the regression guard.

This test proves the opening fence is preserved, but it can still pass if the trailing fence is dropped. Add one assertion for the closing fence marker.

Proposed diff

 		dag.AssertOutputs(t, map[string]any{
 			"RESULT": []test.Contains{
 				test.Contains("```yaml"),
+				test.Contains("\n```"),
 				test.Contains("touch $TEST_FILE"),
 			},
 		})

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@internal/intg/template_test.go` around lines 223 - 226, The test currently
asserts the opening code fence via test.Contains("```yaml") but doesn't verify
the closing fence; update the "RESULT" assertions in the template test (the
slice of test.Contains entries) to include an assertion for the closing fence
marker (for example test.Contains("\n```") or equivalent) right after the
opening-fence check so the test fails if the trailing ``` is dropped.

internal/runtime/node_test.go (1)

229-237: ⚡ Quick win

Add bounded waits to avoid potential test hangs on regressions.

Line 229 and Line 234 block indefinitely. If signal flow regresses, this test can stall until global go test timeout. Use timeout-guarded receives for faster, clearer failures.

Proposed patch

-		<-exec.killStarted
+		select {
+		case <-exec.killStarted:
+		case <-time.After(2 * time.Second):
+			t.Fatal("timeout waiting for Kill to start")
+		}
 		require.Equal(t, core.NodeAborted.String(), node.State().Status.String())

 		close(exec.killContinue)

-		err := <-errCh
+		var err error
+		select {
+		case err = <-errCh:
+		case <-time.After(2 * time.Second):
+			t.Fatal("timeout waiting for Execute to return")
+		}
 		require.Error(t, err)
 		require.Contains(t, err.Error(), "signal: interrupt")

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@internal/runtime/node_test.go` around lines 229 - 237, The test currently
performs unbounded receives on exec.killStarted and errCh which can hang; change
those blocking receives to timeout-guarded selects (e.g., select with
time.After) so the test fails fast on regressions. Specifically, replace the
receive from exec.killStarted and the receive from errCh with select statements
that return a helpful test error if a timeout elapses, and likewise guard the
final assert after closing exec.killContinue; keep assertions using
node.State().Status.String() and core.NodeAborted.String() intact but fail the
test with a clear message if the timeouts trigger.