fix: make cancel work under Git Bash on a non-English Windows (#423) - #577

Four findings from the reviewer and two adversarial review legs on openai#577/openai#580.

`terminateProcessTree` reported success after probing only the root pid, while
`/T` was asked to take the tree, and callers make no second pass. `delivered`
now answers only "did the target die"; the new `treeConfirmed` answers "is
everything under it accounted for". Exit 0 confirms both; exit 128 means there
was no process and so no tree in doubt; only the branch that tolerates a
non-zero taskkill whose root turned out gone reports `treeConfirmed: false`.
`handleCancel` logs that instead of reporting a clean cancellation -- without a
consumer this would have been a relabel, not a fix.

The stale-broker teardown killed whatever process owned a recorded pid. It now
records the broker's OS process start time at spawn and requires it to still
match; unverifiable identity skips the kill and only clears the stale files.
`session-lifecycle-hook.mjs` killed by recorded pid with no such check at all --
the same defect on the path the first fix never reached -- and now shares the
rule. The start-time probe shells out, so `runCommand` grew a `timeout`
passthrough and the probe is bounded at 2 s; a timeout is just an unverifiable
identity. macOS `ps -o lstart=` has only second granularity, which is recorded
at the call site rather than papered over.

Making the hook importable put `main()` behind an entry-point guard, so a test
runs the file exactly as hooks.json does: get that guard wrong and the whole
SessionEnd reaper becomes a silent no-op that nothing else would notice.

Suite: 125 tests, 117 pass, 8 fail -- the 8 are the known platform and
short-path failures that predate this work, and the `cancel` flake is gone.

…nverge

Second review round: the previous fixes closed the reported paths but
introduced two of their own, and left one Windows failure standing.

- process: identify a process by pid AND start time. Comparing broker.json's
  pid against the pid file proved nothing -- both are stale artifacts written
  together, so after the broker died and its pid was recycled they still
  agreed while naming an unrelated process. isProcessAlive had the mirror
  problem: it answers "yes" about whatever now holds the number. Cancel and
  broker teardown now require the recorded start time to match before
  signalling, which matters because terminateProcessTree kills a whole
  process group. Records written before identities existed fall back to the
  old liveness check rather than becoming impossible to cancel.
- broker: only signal the freshly spawned child when its handle still shows
  it running; an exited child's pid may already belong to something else.
- stop gate: converge instead of skipping. Treating stop_hook_active as
  "allow" meant Codex's findings were never re-checked, so the gate passed
  anything on its second pass. The review target is now fingerprinted: an
  unchanged tree re-uses the stored verdict (no extra Codex run, and a block
  stays a block), a changed tree earns a fresh review, and the gate gives up
  after 3 rounds so a disagreement ends with the user instead of more usage.
- stop gate: block via the documented top-level decision/reason pair only.
  The previous commit also emitted hookSpecificOutput and described it as the
  current format, which is backwards.
- process: treat taskkill exit 128 as "already gone". The message-text check
  is English-only, so on a Japanese Windows an already-exited pid threw --
  and handleCancel never caught it, so the job was left un-cancelled. The
  kill is now best-effort and the cancelled state is always recorded.
- process: resolve the Windows spawn wrapper from SystemRoot instead of
  trusting SHELL or ComSpec. Wrapping a JSON-RPC stdio pipe in an arbitrary
  user shell is what hangs the handshake with no surfaced error; SHELL still
  reaches Codex through the inherited env, so its own command execution is
  unchanged.

Verified against upstream: PRs openai#484, openai#577 and openai#580 do exist as open pull
requests (fetched via refs/pull/N/head) and take these same approaches. The
earlier claim that they could not be found was checked against upstream main,
which by definition cannot contain unmerged work.

Tests: new coverage for pid-reuse rejection, the legacy-record fallback, the
taskkill exit code, the Windows shell resolution, and all four stop-gate
outcomes (block, unchanged-reuse, fixed-and-cleared, give-up). The stop-gate
tests fail against the pre-fix hook.

Co-Authored-By: Claude Opus 5 <[email protected]>
Claude-Session: https://claude.ai/code/session_01M5cuwDkeEdktKwmZQhu4ko

Draft one English comment per upstream issue closed by v1.4.0 (Windows
spawn/taskkill cluster, windowsHide, stop-hook stdin deadline, EAGAIN
retries), and update the triage doc's statuses/queue buckets to match:
fixed-in v1.4.0 for those 9 issues plus their reference PRs and openai#326/openai#735,
planned v1.4.1 for openai#336/openai#423/openai#577 (Windows process-identity work deferred
from v1.4.0), and a note on openai#743 that the Windows kill-from-record refusal
now targets v1.4.1. Docs only, nothing posted upstream.

Co-Authored-By: Claude Fable 5.1 <[email protected]>