fix(web): highlight Default in cursor flat-mode model picker

AGENTS.md

@@ -145,9 +145,46 @@ Before commit/push/PR: use the **`pre-push-review`** skill (`~/.cursor/skills/pr
 - **RPC**: CLI registers handlers (`rpc-register`), hub routes requests via `rpcGateway.ts`
 - **Versioned updates**: CLI sends `update-metadata`/`update-state` with version; hub rejects stale
 - **Session modes**: `local` (terminal) vs `remote` (web-controlled); switchable mid-session
-- **Permission modes**: `default`, `acceptEdits`, `bypassPermissions`, `plan`
+- **Permission modes**: `default`, `acceptEdits`, `auto`, `bypassPermissions`, `plan`
 - **Namespaces**: Multi-user isolation via `CLI_API_TOKEN:<namespace>` suffix
 
+## Adding new web features — consider an FUE
+
+When you ship a non-essential feature (the 20% of sessions, not the 80%), consider wrapping its affordance in the generic First-User-Experience primitive so existing users discover it without a giant always-visible UI block.
+
+- **Hook**: `web/src/lib/use-fue.ts` — `useFue(featureId)` returns `{ status, engage, dismiss }`. Storage namespace `hapi.fue.v1.<featureId>` (one localStorage key per feature, isolated from any upstream onboarding flow).
+- **Components**: `web/src/components/Fue.tsx` — `<FueDot>` (small pulsing badge for the affordance) and `<FueCallout>` (portal-rendered popover with title/body + "Got it" affirmative-action dismiss).
+
+Pattern (~10 lines around the affordance):
+
+```tsx
+const fue = useFue('my-feature')
+const buttonRef = useRef<HTMLButtonElement>(null)
+return (
+    <>
+        <button ref={buttonRef} onClick={() => { fue.engage(); doThing() }}>
+            <Icon />
+            {fue.status !== 'acknowledged' ? <FueDot pulsing={fue.status === 'unseen'} /> : null}
+        </button>
+        {fue.status === 'engaging' ? (
+            <FueCallout
+                title={t('myFeature.fueTitle')}
+                body={t('myFeature.fueBody')}
+                onDismiss={fue.dismiss}
+                anchorRef={buttonRef}
+            />
+        ) : null}
+    </>
+)
+```
+
+Rules:
+- Affirmative action only: there is no auto-timeout — user dismisses by clicking "Got it" (reading speed varies).
+- The FUE dot and any feature-specific badge (e.g. an entry counter) should be **mutually exclusive**: onboarding signal beats inventory signal until acknowledged.
+- Storage is opt-in per-feature; if upstream ships its own onboarding for a feature, just don't wrap that affordance.
+
+Canonical example: scratchlist toggle in `web/src/components/AssistantChat/ComposerButtons.tsx` (`ScratchlistToggleButton`).
+
 ## Critical Thinking
 
 1. Fix root cause (not band-aid).

cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@twsxtd/hapi",
-  "version": "0.20.0",
+  "version": "0.20.2",
   "description": "App for agentic coding - access coding agent anywhere",
   "author": "Kirill Dubovitskiy & weishu",
   "license": "AGPL-3.0-only",
@@ -26,11 +26,11 @@
     }
   },
   "optionalDependencies": {
-    "@twsxtd/hapi-darwin-arm64": "0.20.0",
-    "@twsxtd/hapi-darwin-x64": "0.20.0",
-    "@twsxtd/hapi-linux-arm64": "0.20.0",
-    "@twsxtd/hapi-linux-x64": "0.20.0",
-    "@twsxtd/hapi-win32-x64": "0.20.0"
+    "@twsxtd/hapi-darwin-arm64": "0.20.2",
+    "@twsxtd/hapi-darwin-x64": "0.20.2",
+    "@twsxtd/hapi-linux-arm64": "0.20.2",
+    "@twsxtd/hapi-linux-x64": "0.20.2",
+    "@twsxtd/hapi-win32-x64": "0.20.2"
   },
   "scripts": {
     "postinstall": "node -e \"try{require('fs').chmodSync(require('path').join(__dirname,'bin','hapi.cjs'),0o755)}catch(e){}\"",

cli/src/agent/backends/acp/AcpStdioTransport.test.ts

@@ -5,15 +5,25 @@ const guard = vi.hoisted(() => ({
     unregister: vi.fn()
 }));
 
+const spawnState = vi.hoisted(() => ({
+    exitHandlers: [] as Array<(code: number | null, signal: NodeJS.Signals | null) => void>,
+    stdinWrite: vi.fn<(chunk: string) => boolean>(() => true),
+    exitCode: null as number | null
+}));
+
 vi.mock('./agentCliGuard', () => ({
     registerActiveAcpTransport: guard.register,
     unregisterActiveAcpTransport: guard.unregister
 }));
 
 vi.mock('node:child_process', () => ({
     spawn: vi.fn(() => {
+        spawnState.exitHandlers = [];
         const handlers = new Map<string, Array<(...args: unknown[]) => void>>();
         const proc = {
+            get exitCode() {
+                return spawnState.exitCode;
+            },
             stdout: {
                 setEncoding: vi.fn(),
                 on: vi.fn((event: string, handler: (...args: unknown[]) => void) => {
@@ -26,12 +36,15 @@ vi.mock('node:child_process', () => ({
                     handlers.set(`stderr:${event}`, [...(handlers.get(`stderr:${event}`) ?? []), handler]);
                 })
             },
-            stdin: { end: vi.fn(), write: vi.fn() },
+            stdin: {
+                end: vi.fn(),
+                write: (chunk: string) => spawnState.stdinWrite(chunk)
+            },
             on: vi.fn((event: string, handler: (...args: unknown[]) => void) => {
-                handlers.set(`proc:${event}`, [...(handlers.get(`proc:${event}`) ?? []), handler]);
                 if (event === 'exit') {
-                    queueMicrotask(() => handler(0, null));
+                    spawnState.exitHandlers.push(handler as (code: number | null, signal: NodeJS.Signals | null) => void);
                 }
+                handlers.set(`proc:${event}`, [...(handlers.get(`proc:${event}`) ?? []), handler]);
             }),
             kill: vi.fn()
         };
@@ -45,6 +58,10 @@ describe('AcpStdioTransport agent CLI guard', () => {
     afterEach(() => {
         guard.register.mockClear();
         guard.unregister.mockClear();
+        spawnState.stdinWrite.mockReset();
+        spawnState.stdinWrite.mockReturnValue(true);
+        spawnState.exitCode = null;
+        spawnState.exitHandlers = [];
     });
 
     test('registers cross-process guard only for Cursor agent command', async () => {
@@ -64,3 +81,39 @@ describe('AcpStdioTransport agent CLI guard', () => {
         }
     });
 });
+
+describe('AcpStdioTransport closed stdin writes', () => {
+    afterEach(() => {
+        spawnState.stdinWrite.mockReset();
+        spawnState.stdinWrite.mockReturnValue(true);
+        spawnState.exitCode = null;
+        spawnState.exitHandlers = [];
+    });
+
+    test('rejects new requests after the ACP process exits instead of throwing from stdin.write', async () => {
+        const transport = new AcpStdioTransport({ command: 'gemini' });
+        spawnState.exitCode = 1;
+        spawnState.stdinWrite.mockImplementation(() => {
+            throw new Error('WritableIterable is closed');
+        });
+
+        for (const handler of spawnState.exitHandlers) {
+            handler(1, null);
+        }
+
+        await expect(transport.sendRequest('session/new')).rejects.toThrow(
+            'ACP process exited (code=1, signal=null)'
+        );
+        expect(() => transport.sendNotification('session/cancel', {})).not.toThrow();
+    });
+
+    test('rejects pending requests when stdin.write throws', async () => {
+        spawnState.stdinWrite.mockImplementation(() => {
+            throw new Error('WritableIterable is closed');
+        });
+
+        const transport = new AcpStdioTransport({ command: 'gemini' });
+        await expect(transport.sendRequest('initialize')).rejects.toThrow('WritableIterable is closed');
+        await expect(transport.sendRequest('session/new')).rejects.toThrow('WritableIterable is closed');
+    });
+});

cli/src/agent/backends/acp/AcpStdioTransport.ts

@@ -63,6 +63,8 @@ export class AcpStdioTransport {
     private nextId = 1;
     private protocolError: Error | null = null;
     private guardReleased = false;
+    private closed = false;
+    private closeError: Error | null = null;
 
     constructor(options: {
         command: string;
@@ -94,14 +96,14 @@ export class AcpStdioTransport {
             this.releaseAgentCliGuard();
             const message = `ACP process exited (code=${code ?? 'null'}, signal=${signal ?? 'null'})`;
             logger.debug(message);
-            this.rejectAllPending(new Error(message));
+            this.markClosed(new Error(message));
         });
 
         this.process.on('error', (error) => {
             this.releaseAgentCliGuard();
             logger.debug('[ACP] Process error', error);
             const message = error instanceof Error ? error.message : String(error);
-            this.rejectAllPending(new Error(
+            this.markClosed(new Error(
                 `Failed to spawn ${options.command}: ${message}. Is it installed and on PATH?`,
                 { cause: error }
             ));
@@ -124,6 +126,10 @@ export class AcpStdioTransport {
     static readonly DEFAULT_TIMEOUT_MS = 120_000;
 
     async sendRequest(method: string, params?: unknown, options?: { timeoutMs?: number }): Promise<unknown> {
+        if (this.closed) {
+            return Promise.reject(this.closeError ?? new Error('ACP transport is closed'));
+        }
+
         const id = this.nextId++;
         const payload: JsonRpcRequest = {
             jsonrpc: '2.0',
@@ -167,6 +173,10 @@ export class AcpStdioTransport {
     }
 
     sendNotification(method: string, params?: unknown): void {
+        if (this.closed) {
+            return;
+        }
+
         const payload: JsonRpcNotification = {
             jsonrpc: '2.0',
             method,
@@ -179,7 +189,7 @@ export class AcpStdioTransport {
         this.process.stdin.end();
         await killProcessByChildProcess(this.process);
         this.releaseAgentCliGuard();
-        this.rejectAllPending(new Error('ACP transport closed'));
+        this.markClosed(new Error('ACP transport closed'));
     }
 
     private releaseAgentCliGuard(): void {
@@ -302,8 +312,27 @@ export class AcpStdioTransport {
     }
 
     private writePayload(payload: JsonRpcRequest | JsonRpcNotification | JsonRpcResponse): void {
-        const serialized = JSON.stringify(payload);
-        this.process.stdin.write(`${serialized}\n`);
+        if (this.closed) {
+            return;
+        }
+
+        try {
+            const serialized = JSON.stringify(payload);
+            this.process.stdin.write(`${serialized}\n`);
+        } catch (error) {
+            const writeError = error instanceof Error ? error : new Error(String(error));
+            this.markClosed(writeError);
+        }
+    }
+
+    private markClosed(error: Error): void {
+        if (this.closed) {
+            return;
+        }
+
+        this.closed = true;
+        this.closeError = error;
+        this.rejectAllPending(error);
     }
 
     private rejectAllPending(error: Error): void {