1 files changed, 95 insertions, 0 deletions
diff --git a/modules/test/test-aiasm-rejection.js b/modules/test/test-aiasm-rejection.js
new file mode 100644
index 0000000..d6e18f6
--- /dev/null
+++ b/modules/test/test-aiasm-rejection.js
@@ -0,0 +1,95 @@
+// node modules/test/test-aiasm-rejection.js
+// test-aiasm-rejection — the wx / webxai / webx aliases must not turn the AI chat-lock timeout
+// into an unhandled promise rejection (RPT-20261107-150726-bf727247).
+//
+// Why this file exists: forwardToAI() used to call the assistant's chat(args) with no await and no
+// .catch() inside a non-async function. When the assistant was already mid-turn, chat() waited
+// _chatLockTimeoutMs (10s) and then rejected with "AI is still busy with another turn…". Nothing
+// was attached to that promise, so it surfaced on window.unhandledrejection and the debug
+// supervisor auto-filed a bug report for what is normal "the user typed twice" UX.
+const fs = require('fs');
+const path = require('path');
+
+const SRC = path.join(__dirname, '..', 'core', 'module-aiasm.js');
+const Alias = new Function(fs.readFileSync(SRC, 'utf8') + '\nreturn WebXAIAliasModule;')();
+
+const BUSY = 'AI is still busy with another turn (waited 10s). Wait for it to finish, or run '
+    + "'ai-stop' and retry — the running turn's lock is left alone.";
+
+const unhandled = [];
+process.on('unhandledRejection', (e) => unhandled.push(e));
+
+let passes = 0, fails = 0;
+function ok(name, cond, detail) {
+    if (cond) { passes++; return; }
+    fails++;
+    console.log('FAIL ' + name + (detail ? ' — ' + detail : ''));
+}
+
+function mk(chatImpl) {
+    const printed = [];
+    const term = {
+        print: (msg, kind) => printed.push({ msg: String(msg), kind: kind || '' }),
+        moduleManager: { modules: { WebX11AIAssistantModule: chatImpl ? { chat: chatImpl } : null } },
+        ollamaManager: { chat: () => Promise.resolve('ok') }
+    };
+    const m = new Alias();
+    m.terminal = term;
+    m.registerCommands();
+    return { m, printed, term };
+}
+
+const tick = (ms) => new Promise(r => setTimeout(r, ms || 25));
+
+(async () => {
+    // A1-A5: the busy rejection is printed, the returned promise settles, nothing escapes
+    const a = mk(() => Promise.reject(new Error(BUSY)));
+    const r = a.m.forwardToAI(['hi']);
+    ok('A1 forwardToAI returns a promise (callers can await it)', !!r && typeof r.then === 'function', typeof r);
+    let awaited;
+    try { awaited = await r; } catch (e) { awaited = 'REJECTED:' + e.message; }
+    ok('A2 the returned promise settles instead of rejecting', String(awaited).indexOf('REJECTED') !== 0, String(awaited));
+    const errLine = a.printed.find(p => /^AI error: /.test(p.msg));
+    ok('A3 the busy timeout is printed to the terminal', !!errLine && /still busy/.test(errLine.msg),
+        JSON.stringify(a.printed));
+    ok('A4 it is printed as an error line', !!errLine && errLine.kind === 'error', errLine && errLine.kind);
+    await tick();
+    ok('A5 no unhandledRejection escaped', unhandled.length === 0,
+        unhandled.map(e => (e && e.message) || String(e)).join('; '));
+
+    // A6-A7: the same through the command map the terminal dispatcher actually awaits
+    const b = mk(() => Promise.reject(new Error(BUSY)));
+    let cmdErr = null;
+    try { await b.m.commands['wx'](['second question']); } catch (e) { cmdErr = e; }
+    ok('A6 `wx` command does not reject', !cmdErr, cmdErr && cmdErr.message);
+    await tick();
+    ok('A7 `wx` prints the busy error', b.printed.some(p => /AI error: .*still busy/.test(p.msg)),
+        JSON.stringify(b.printed));
+
+    // A8-A10: happy path — a resolving chat must print nothing at all
+    const c = mk(() => Promise.resolve({ role: 'assistant', content: 'pong' }));
+    let res;
+    try { res = await c.m.forwardToAI(['ping']); } catch (e) { res = 'REJECTED:' + e.message; }
+    await tick();
+    ok('A8 a resolving chat prints nothing', c.printed.length === 0, JSON.stringify(c.printed));
+    ok('A9 happy path does not throw', String(res).indexOf('REJECTED') !== 0, String(res));
+    ok('A10 happy path leaks no unhandled rejection', unhandled.length === 0, String(unhandled.length));
+
+    // A11-A12: ollama fallback (no assistant module) is handled the same way
+    const d = mk(null);
+    d.term.ollamaManager.chat = () => Promise.reject(new Error('ollama offline'));
+    await d.m.forwardToAI(['hi']);
+    await tick();
+    ok('A11 ollama fallback failure is printed', d.printed.some(p => /AI error: ollama offline/.test(p.msg)),
+        JSON.stringify(d.printed));
+    ok('A12 ollama fallback leaks no unhandled rejection', unhandled.length === 0, String(unhandled.length));
+
+    // A13: usage is still printed when the question is missing
+    const e = mk(null);
+    e.m.forwardToAI([]);
+    ok('A13 usage printed when args are empty', e.printed.some(p => /Usage: webxai/.test(p.msg)),
+        JSON.stringify(e.printed));
+
+    console.log('test-aiasm-rejection: ' + passes + ' passed, ' + fails + ' failed');
+    process.exit(fails ? 1 : 0);
+})();