feat: Commands system enhancements - #396

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

Inline comments:
In `@docs/commands.md`:
- Around line 62-69: The example middleware uses await inside a non-async arrow
function; change the anonymous middleware signature to an async function so
await next() is valid (e.g., make the arrow function async (command, input,
context, next) => { const result = await next(); return result; }); ensure the
symbols mentioned (next and result) remain and the function signature reflects
async to match the later example.

In `@packages/room-store/src/CommandSlice.ts`:
- Around line 389-404: The code unconditionally calls
invokeCommandSliceCallback(props?.onCommandInvokeSuccess, ...) even when
normalizeCommandExecuteResult(command.id, rawResult) yields a failure object;
change the flow in CommandSlice.ts so that after computing normalizedResult you
check normalizedResult.success (or equivalent flag) and only call
invokeCommandSliceCallback with props?.onCommandInvokeSuccess when success ===
true; when success === false, call the failure callback
(props?.onCommandInvokeFailure or the appropriate failure handler) with the same
payload (command, input, context, result, durationMs) and use
get().room.captureException for error reporting—update the branches around
normalizeCommandExecuteResult and invokeCommandSliceCallback to reflect this
conditional dispatch.
- Around line 687-694: The invokeMiddleware chain currently hands middleware a
raw async next() allowing multiple calls; wrap the next callback returned to
each middleware with a local "called" guard so calling next() more than once
throws an error (or returns a rejected promise) to prevent duplicate execution.
In practice, inside invokeMiddleware(index) capture currentMiddleware and supply
it a wrapped next that checks a boolean flag (e.g., called) and sets it before
invoking invokeMiddleware(index+1), throwing/rejecting if called is already
true; keep the existing fallback to command.execute(context, input) when no
middleware remains. This change touches invokeMiddleware, currentMiddleware,
middleware, command.execute and the next() callback passed into middleware.

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

Inline comments:
In `@packages/room-store/src/CommandSlice.ts`:
- Around line 594-601: The loop over keystrokes currently calls keystroke.trim()
assuming every element is a string; guard against malformed/non-string elements
by checking typeof keystroke === 'string' before calling trim (or use
String(keystroke).trim() if you want to coerce), skip empty results, and then
add the normalized value to deduplicated; apply the same defensive change to the
other identical block that operates on keystrokes (the block referenced around
symbols keystroke, keystrokes, deduplicated).

---

Nitpick comments:
In `@packages/room-store/src/CommandSlice.ts`:
- Around line 364-371: The early-return when resolveCommandEnabled(command,
executionContext) is false should still fire the same lifecycle callbacks as
other failure paths: before returning the { success: false, commandId:
command.id, code: 'command-disabled', ... } result, invoke the
lifecycle/telemetry emission used elsewhere in this file for failed invocations
(the same pattern used in the other early-exit branches around lines 373-383)
and pass the command id, name, executionContext and the error payload (code
'command-disabled' and the message) so telemetry subscribers receive the
disabled-command event.