Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@packages/hexbus/src/logger.ts`:
- Around line 93-119: The switch over logLevel in packages/hexbus/src/logger.ts
is duplicating openTuiMessage(formattedMessage) in every non-error branch;
simplify by making the "error" case handle its TTY fallback (if
process.stdin.isTTY && process.stdout.isTTY then call
openTuiMessage(formattedMessage) else write to process.stderr), and collapse all
other cases (warn, info, debug, success, failed, default) to a single
fall-through that just calls openTuiMessage(formattedMessage); update the switch
or replace it with an if/else using the existing symbols logLevel,
formattedMessage, openTuiMessage and the TTY check to remove the duplicated
calls.

In `@packages/hexbus/src/opentui.ts`:
- Around line 289-299: getSession retains a rejected sessionPromise so the TUI
is permanently broken; wrap the await of sessionPromise (created via
sessionPromise ??= createSession()) in a try/catch: assign sessionPromise before
awaiting, then in the catch set sessionPromise = null (and leave activeSession
null) and rethrow the error so callers see the failure, ensuring subsequent
calls to getSession will retry createSession; reference sessionPromise,
getSession, createSession, activeSession, and cancelScheduledClose when making
the change.
- Around line 801-838: The non-openTui branch of openTuiExit currently calls
process.exit synchronously and can prevent the runner's finally block (which
calls transcript?.close(...)) from running; change openTuiExit to ensure the
transcript is closed/flushes before exiting when !canUseOpenTui() by awaiting
the shared transcript close hook (or invoking a closeTranscript/flushTranscript
function) prior to calling process.exit — locate openTuiExit and canUseOpenTui
and add an awaited call to the same transcript?.close(...) logic used by
runner.ts (or a centrally exported close function) so the transcript is
guaranteed to be closed before process.exit is invoked.
- Around line 136-140: clearChildren: no change required—box.getChildren()
already returns a snapshot so you can leave clearChildren(box: BoxRenderable)
as-is. getSession: avoid leaving a permanently rejected sessionPromise by
changing the sessionPromise assignment to use a temporary promise (e.g., const p
= createSession()), set sessionPromise = p, then await p.catch(err => { if
(sessionPromise === p) sessionPromise = undefined; throw err; }) so a rejection
clears sessionPromise and allows retries; reference sessionPromise and
createSession. openTuiExit: do not call process.exit(exitCode) synchronously in
the non-TTY (!canUseOpenTui()) branch because it can bypass runCli()'s
finally/await transcript.close; instead either return the exitCode to the caller
(so the caller calls process.exit after cleanup) or schedule the exit
asynchronously (e.g., setImmediate(() => process.exit(exitCode))) so
transcript.close/runCli() finally handlers can run; reference openTuiExit,
runCli, and transcript.close.

In `@packages/hexbus/src/runner.ts`:
- Around line 815-817: The version check calls handleVersionRequest(options,
rawArgs, state.context) before state.context is initialized, so context (and its
logger) is always undefined; either initialize state.context (so logger is
available) before invoking handleVersionRequest or remove the new context
parameter and logger forwarding from handleVersionRequest/printVersionInfo; to
fix, move the context creation (assignment to state.context) to before the if
(await handleVersionRequest(...)) call so handleVersionRequest and
printVersionInfo receive a valid context.logger, or alternatively remove the
context argument from handleVersionRequest and the logger: context?.logger usage
in printVersionInfo to keep behavior unchanged.
- Around line 848-852: handleRunnerError -> state.context.error.handleError ->
handleError -> openTuiExit currently calls process.exit synchronously on
non-TTY, which bypasses the finally block that calls transcript.close in
runner.ts; to fix, change openTuiExit (and its callers like handleError) to not
call process.exit directly but instead surface the intended exit code by
throwing a dedicated ExitError (or returning the code) so the caller
(handleRunnerError/runner.ts) can let the exception propagate and run the
finally block where transcript?.close(...) executes; ensure the thrown ExitError
carries the exit code and update handleError/openTuiExit docs/comments to
reflect the new behavior.

In `@packages/hexbus/src/transcript.ts`:
- Around line 217-232: close() is declared to return Promise<void> but only
performs synchronous I/O and returns Promise.resolve(), which misleads callers;
make it truly asynchronous by converting the body to async and using
non-blocking file writes: mark close(...) as async, replace the synchronous
appendJsonLine/appendFileSync calls with their Promise-based equivalents (e.g.,
use appendJsonLine that returns a Promise or fs.promises.appendFile for
options.format === "jsonl"), await those calls, and then return/allow implicit
resolution; keep restoring originalStdoutWrite/originalStderrWrite and
preserving durationMs/exitCode/timestamp logic referencing options.format,
options.filePath and startedAt.
- Around line 130-156: The argument parsing loop in transcript.ts currently
unconditionally consumes the next token for spaced flags (--log-file,
--log-format) by doing index++ and using rawArgs[index+1], which can skip a
following real argument if the next token is missing or itself a flag. Update
the handling for the "--log-file" and "--log-format" cases inside the for loop
to first check that rawArgs[index + 1] exists and does not start with "--"
before assigning filePath or format and incrementing index; otherwise treat the
flag as having no value (leave filePath/format unchanged or null) so later code
that calls normalizeFormat or valueAfterEquals behaves correctly. Use the
existing valueAfterEquals and normalizeFormat helpers for the equals-form
branches unchanged.
- Around line 214-215: Add a one-time process exit handler to ensure the
original stdout/stderr write functions are restored and the transcript is closed
on unexpected exits: register process.once listeners for 'exit' and signal
events like 'SIGINT' and 'SIGTERM' that call the module/class close() (or an
internal restore method) and restore process.stdout.write and
process.stderr.write back to the saved originals
(captureStdoutWrite/captureStderrWrite should have saved the originals) before
returning; ensure handlers are idempotent so repeated signals don't double-close
and remove or ignore handlers after normal close() completes.

---

Outside diff comments:
In `@packages/hexbus/src/errors.ts`:
- Around line 302-317: The withErrorHandling wrapper currently calls
CliError.from/error.display and then process.exit(1), bypassing the OpenTUI exit
flow; update it to delegate to the centralized exit handler (e.g., use
createErrorHandlers.handleError or call openTuiExit(messages, 1) via the same
pathway used by createErrorHandlers) so errors go through the unified
rendering/transcript logic—locate the withErrorHandling function, remove the
direct process.exit(1) call, and invoke the shared error/exit helper with the
CliError (or its message payload and exit code) to preserve consistent OpenTUI
behavior.

In `@packages/hexbus/src/intro.ts`:
- Around line 36-45: The function displayIntro has an unused parameter context;
rename it to _context in the function signature (keep the type Pick<CliContext,
"logger">) and update its JSDoc to indicate the logger is intentionally unused
to silence linters and clarify intent; leave openTuiIntro calls and caller sites
(runner.ts and tests) unchanged since this is not a breaking API change. Ensure
the identifier change is applied to the export in src/index.ts if it re-exports
the same symbol so the signature remains consistent.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Duplicate comments:
In `@packages/hexbus/src/transcript.ts`:
- Around line 130-136: The helper nextFlagValue currently treats only tokens
starting with "--" as flags, so short-form flags like "-h" are mistakenly
accepted as values; update the check in nextFlagValue (params rawArgs, index) to
treat any token that begins with "-" as a flag (e.g., use value !== undefined &&
!value.startsWith("-") or a regex like /^-/) so short options are considered
missing values; keep the same return semantics (return the next token only if it
does not look like a flag).