[worktrunk-bot]

Problem

The nushell wrapper's --execute directive call wasn't wrapped in try. Nushell 0.98+ raises a ShellError on a non-zero external exit, so a --execute body that exits non-zero unwound the whole def — cleanup never ran, all three mktemp files leaked, and the stdout the function still had to return was discarded. Cleanup has always sat after the exec call, so this is pre-existing.

Verified end-to-end against nushell 0.114.1 (the version CI pins) driving the real rendered wrapper in a dedicated TMPDIR:

	before	after
wt switch --create … --execute "echo BODY; exit 42"	exit 42, 3 temp files leaked	exit 42, 0 leaked
wt switch --definitely-not-a-flag (wt itself fails)	exit 2, 0 leaked	unchanged
happy path (--execute "echo OK", then wt config show)	exit 0, stdout returned, 0 leaked	unchanged

The bare mechanism, with no wrapper involved:

def wrapper [] {
    let f = (mktemp --tmpdir)
    if true { ^sh -c "exit 42" }
    print "REACHED_AFTER_EXEC"     # never prints
    "RETVAL"                       # never returned
}

Why the existing test stayed green

test_wrapper_execute_exit_code_propagation already drives this exact command for nu and passes — but it passes because the unwind happens to carry exit 42 out to the shell, not because the wrapper handled it. The assertion the test makes is satisfied by the failure mode, so the leak sat on a path that looked covered.

Solution

Wrap the exec call in try, the same way the binary call above it already is, and fold the body's exit code into $exit_code:

let exec_exit = if ($exec_file | path exists) and (open $exec_file --raw | str trim | is-not-empty) {
    let script = open $exec_file --raw
    try { ^sh -c $script; 0 } catch { $env.LAST_EXIT_CODE }
} else {
    0
}

let exit_code = if $exit_code != 0 { $exit_code } else { $exec_exit }

The end of the function then propagates it through the existing ^sh -c $"exit ($exit_code)" path, so the 42 is the wrapper's doing rather than a side effect of the unwind — and cleanup runs on the way.

#3733 flagged the precedence question — when both wt and the body fail, which code wins — as a user-visible contract rather than a mechanical port. It turns out the contract is already set: bash, zsh and fish all guard their src_exit assignment with if $exit_code -eq 0, i.e. first non-zero wins, wt before the body. This mirrors that rather than inventing a nushell-specific rule, which is what took it from an issue to a PR.

^sh -c $script keeps its non-terminal position inside the try block, so the body's stdout still goes straight to the terminal — verified above (BODY appears in both columns).

Testing

test_nu_wrapper_execute_failure_runs_cleanup in tests/integration_tests/shell_wrapper.rs runs the real wrapper through a PTY against a dedicated TMPDIR and asserts both halves: the body's exit code still reaches the caller, and the temp dir is empty afterwards. It fails on the current template with leaked temp files: ["tmp.zyJKCYvPHq", "tmp.eF7z3IFox0", "tmp.0sJXkEnCXb"] and passes with the fix.

The temp-dir assertion is the part that distinguishes the two states — WT_EXIT:42 is present in the failing run too, which is exactly why the pre-existing test couldn't catch this. The driving script wraps the wt call in nushell's own try, since the wrapper's terminal ^sh -c $"exit …" is meant to abort the caller; without that the intended propagation would hide whether cleanup ran first.

Also run locally: cargo test --lib --bins (2,450 passed, including the regenerated init_nu snapshot), the full shell_wrapper module with --features shell-integration-tests (62 passed), and test_docs_are_in_sync + shell_init + config_show (129 passed).

Relationship to #3732

Same abort-before-cleanup shape, different site: #3732 fixes the cleanup rm call, this fixes the exec call. Neither fixes the other's site, and they're separately revertable.

Resolved. #3732 merged first, so origin/main is now merged into this branch (938976ec8). The conflict was in templates/nushell.nu and the init_nu snapshot, exactly as predicted — resolution was mechanical: this PR's let exit_code fold stays, and the old rm -f $cd_file $exec_file line it sat above is gone, replaced by #3732's consolidated try { ^rm -f … } block after the let output read. cargo test --lib shell::tests::test_shell_init_generate confirms the regenerated snapshot matches the resolved template.

A third site in the same function is not covered by either PR: cd $target_dir in the cd-directive block raises on a missing or inaccessible directory and unwinds the def the same way, leaking the same three temp files. Left for a follow-up so this PR stays one concern.

---

Closes #3733 — automated triage

[worktrunk-bot]

Verified the fix itself against nushell 0.114.1 rather than taking the description's word for it — pre-fix the def unwinds before cleanup, post-fix cleanup runs, the body's stdout still streams ahead of the wrapper's own return, and the let exit_code = if $exit_code != 0 { … } shadowing resolves the previous binding on the RHS as intended (wt's code wins, body's code otherwise). No defect in the diff. Two things adjacent to it:

The "should merge without conflict" claim about #3732 is wrong. git merge-tree on the two PR heads reports content conflicts in both files:

CONFLICT (content): Merge conflict in src/shell/snapshots/worktrunk__shell__tests__init_nu.snap
CONFLICT (content): Merge conflict in templates/nushell.nu

On the base, ^sh -c $script is line 123 and rm -f $cd_file $exec_file is line 126 — three apart, so each PR's changed lines sit inside the other's context. This PR rewrites the former and inserts the let exit_code fold immediately above the latter; #3732 rewrites the rm lines and hoists let output above them. Resolution is mechanical (keep both, fold goes before the cleanup block), but whichever lands second needs a manual rebase. I've corrected the description.

The same abort-before-cleanup shape sits at a third site 15 lines up, unfixed. In the cd-directive block (# cd file holds a raw path — no shell parsing needed), cd $target_dir raises on a missing or inaccessible directory and unwinds the whole def exactly as the exec call did:

def wrapper_cd [target: string] {
    cd $target
    print "CLEANUP_RAN"   # never prints
    "RETVAL"
}

On nu 0.114.1 that catches as an error with no CLEANUP_RAN — same three leaked temp files, same discarded stdout. So the function has three abort sites: this PR fixes exec, #3732 fixes rm, cd remains. Separately, bash, zsh and fish fold a cd_exit into exit_code under the same first-non-zero-wins rule this PR adopts for src_exit; the nushell wrapper folds neither. Both are out of scope here — I'm not opening a third overlapping nushell PR while these two already conflict, and it wants its own test either way. Happy to follow up once these land.

The reachability of the cd case is low (wt writes a path it just resolved; it takes a concurrent removal or a permissions change to miss), which is probably why it hasn't surfaced — noting it so the merge isn't read as closing out the whole function.

[max-sixty]

@worktrunk-bot resolve conflicts

[worktrunk-bot]

Reviewed the conflict resolution in 938976ec8, not just the description's account of it. It holds: git diff origin/main..938976ec8 -- templates/nushell.nu is exactly this PR's own hunk and nothing else, so #3732's consolidated try { ^rm -f $cd_file $exec_file $stdout_file } block — and its hide rm / ^rm-vs-builtin rationale — came through the merge intact, with the let exit_code fold landing above the let output read where it needs to be. The regenerated init_nu snapshot is byte-identical to the merged template with {{ cmd }} → wt substituted, which is the only substitution the render performs, so the snapshot can't be silently stale.

That closes the one live point from my earlier review — the "should merge without conflict" claim, which the description now records as resolved. The cd $target_dir site remains the third abort path in this function, still unfixed by either PR and still out of scope here; it's now unblocked for a follow-up, since the two overlapping PRs have converged.

Not approving: self-authored, so GitHub blocks it — the merge call is yours.

[worktrunk-bot]

Conflicts resolved — origin/main merged in as 938976ec8. Both conflicts (templates/nushell.nu and the init_nu snapshot) resolved by keeping this PR's let exit_code fold and dropping the rm -f $cd_file $exec_file line it sat above, which #3732 replaced with its consolidated try { ^rm -f … } block after the let output read. Everything is terminal and green on the merge commit, including test (linux|macos|windows) and codecov/patch; the description's "Relationship to #3732" section is updated to record the resolution rather than predict the conflict.