crewly 1.20.261 → 1.20.263

package/dist/cli/backend/src/services/agent/agent-registration.service.js

@@ -9,6 +9,7 @@ import { LoggerService } from '../core/logger.service.js';
 import { getRestoreQueue } from './restore-queue.js';
 import { ResourceModeService, RESOURCE_MODE_CONSTANTS } from './resource-mode.service.js';
 import { createSessionCommandHelper, getSessionBackendSync, createSessionBackend, getSessionStatePersistence, } from '../session/index.js';
+import { DEFAULT_TERMINAL_COLS, DEFAULT_TERMINAL_ROWS } from '../session/session-backend.interface.js';
 import { RuntimeServiceFactory } from './runtime-service.factory.js';
 import { OrcReplyRouteService } from '../orc/orc-reply-route.service.js';
 import { registerInProcessRuntime, unregisterInProcessRuntime, } from './crewly-agent/in-process-runtime-registry.js';
@@ -20,7 +21,7 @@ import { extractSlackThreadKeys, formatSlackThreadKey } from '../slack/slack-thr
 import { delay } from '../../utils/async.utils.js';
 import { buildRuntimeModelFlags } from '../../utils/runtime-model-flags.utils.js';
 import { buildRemoteMcpLaunchFlags } from '../connector/remote-mcp-launch.service.js';
-import { effectiveMemberModelId } from '../../utils/member-default-model.utils.js';
+import { effectiveMemberModelId, fallbackRuntimeModelId } from '../../utils/member-default-model.utils.js';
 import { canMemberDelegate, getLeadSubordinates } from '../../utils/team.utils.js';
 import { stripToolCallMarkup } from '../../utils/tool-call-markup.utils.js';
 import { appendIncompleteNotice } from '../../utils/incomplete-turn.utils.js';
@@ -3253,9 +3254,13 @@ Loop until done, blocked, or explicitly reassigned:
                 fallbackCrewlyAgentModel = launch.crewlyAgentModel;
                 try {
                     const found = role === ORCHESTRATOR_ROLE ? null : await this.storageService.findMemberBySessionName(sessionName);
+                    // The model is resolved for the runtime that really runs: a
+                    // model meant for the configured runtime is not passed on, and
+                    // reviewed members get that runtime's default (Sonnet on Claude).
+                    const fallbackModel = found ? fallbackRuntimeModelId(found.team, found.member, runtimeType) : undefined;
                     runtimeFlags = [
                         ...(await this.resolveRuntimeFlags(role, runtimeType, found?.member.skillOverrides, found?.member.excludedRoleSkills)),
-                        ...this.resolveModelFlags(sessionName, runtimeType, undefined, undefined),
+                        ...this.resolveModelFlags(sessionName, runtimeType, fallbackModel, undefined),
                     ];
                 }
                 catch {
@@ -4431,6 +4436,55 @@ Loop until done, blocked, or explicitly reassigned:
         const queueSize = queue.getQueueSize(sessionName);
         return { position: queue.positionOf(sessionName, message) ?? queueSize, queueSize };
     }
+    /**
+     * Make a session's runtime redraw its screen (SIGWINCH): one column and
+     * row larger, then back to its current size. Uses the backend's resize
+     * (PTY and screen buffer together) at the session's real size, never a
+     * fixed 80x24 — that would shrink an agent's terminal back to the size
+     * whose too-short window hid the input box (2026-10-08 Ella).
+     *
+     * @param sessionHelper - The session helper
+     * @param sessionName - The session
+     */
+    async repaintBySigwinch(sessionHelper, sessionName) {
+        const backend = typeof sessionHelper.getBackend === 'function' ? sessionHelper.getBackend() : null;
+        const dims = backend?.getTerminalDimensions?.(sessionName) ?? { cols: DEFAULT_TERMINAL_COLS, rows: DEFAULT_TERMINAL_ROWS };
+        const resize = (cols, rows) => {
+            if (backend?.resizeSession)
+                backend.resizeSession(sessionName, cols, rows);
+            else
+                sessionHelper.getSession(sessionName)?.resize(cols, rows);
+        };
+        resize(dims.cols + 1, dims.rows + 1);
+        await delay(200);
+        resize(dims.cols, dims.rows);
+    }
+    /**
+     * Whether an agent is mid-turn, for the unreadable-input restart: a live
+     * turn on screen (busy bar / spinner that is repainting), or agent output
+     * within `quietMs` (Crewly's own resize redraws are not counted, see
+     * PtyActivityTrackerService.ignoreOutputFor). Unsure counts as mid-turn.
+     *
+     * @param sessionName - The agent
+     * @param quietMs - How long without output counts as not mid-turn
+     * @returns True when the agent may be working
+     */
+    async isMidTurnForRecovery(sessionName, quietMs) {
+        try {
+            const helper = await this.getSessionHelper();
+            if (!helper.sessionExists(sessionName))
+                return true;
+            if (await helper.isAgentBusy(sessionName))
+                return true;
+            const tracker = PtyActivityTrackerService.getInstance();
+            if (!tracker.hasActivity(sessionName))
+                return false;
+            return tracker.getIdleTimeMs(sessionName) < quietMs;
+        }
+        catch {
+            return true;
+        }
+    }
     /**
      * For a Claude Code agent that is mid-turn, queue the message instead of
      * pasting it into the running turn (see {@link holdForBusyAgent}). Other
@@ -4655,11 +4709,8 @@ Loop until done, blocked, or explicitly reassigned:
                     // This matches the manual workaround where pressing a key in the
                     // frontend terminal "wakes up" the input handler.
                     try {
-                        const session = sessionHelper.getSession(sessionName);
-                        if (session) {
-                            session.resize(81, 25);
-                            await delay(200);
-                            session.resize(80, 24);
+                        if (sessionHelper.getSession(sessionName)) {
+                            await this.repaintBySigwinch(sessionHelper, sessionName);
                             await delay(300);
                         }
                     }
@@ -4683,11 +4734,8 @@ Loop until done, blocked, or explicitly reassigned:
                     if (attempt > 1) {
                         // PTY resize to trigger SIGWINCH → Ink re-render
                         try {
-                            const session = sessionHelper.getSession(sessionName);
-                            if (session) {
-                                session.resize(81, 25);
-                                await delay(200);
-                                session.resize(80, 24);
+                            if (sessionHelper.getSession(sessionName)) {
+                                await this.repaintBySigwinch(sessionHelper, sessionName);
                                 await delay(300);
                             }
                         }
@@ -4720,12 +4768,8 @@ Loop until done, blocked, or explicitly reassigned:
                     // re-render the TUI and potentially restore focus state.
                     if (needsResize) {
                         try {
-                            const session = sessionHelper.getSession(sessionName);
-                            if (session) {
-                                // Resize slightly then back to trigger SIGWINCH
-                                session.resize(81, 25);
-                                await delay(200);
-                                session.resize(80, 24);
+                            if (sessionHelper.getSession(sessionName)) {
+                                await this.repaintBySigwinch(sessionHelper, sessionName);
                                 await delay(500);
                                 this.logger.debug('PTY resize sent to trigger TUI re-render', {
                                     sessionName,