crewly 1.20.153 → 1.20.155

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

@@ -26,10 +26,12 @@ import { ContextWindowMonitorService } from './context-window-monitor.service.js
 import { OAuthReloginMonitorService } from './oauth-relogin-monitor.service.js';
 import { SubAgentMessageQueue } from '../messaging/sub-agent-message-queue.service.js';
 import { InFlightTurnTracker } from '../restart/in-flight-turn-tracker.service.js';
+import { FreshTaskConversationService } from './fresh-task-conversation.service.js';
 import { RestartDrainService } from '../restart/restart-drain.service.js';
 import { AgentSuspendService } from './agent-suspend.service.js';
 import { PromptBuilderService, buildModuleConfigFromTeamMember, memberSkillsJson, } from '../ai/prompt-builder.service.js';
 import { PromptAssemblyService } from '../ai/prompt-modules/prompt-assembly.service.js';
+import { renderActiveWorkSection } from '../ai/prompt-modules/active-work.module.js';
 import { resolveOrcPromptProfile, ORC_PROMPT_PROFILE_ENV, } from '../ai/prompt-modules/prompt-module.interface.js';
 import { stripAnsiCodes } from '../../utils/terminal-output.utils.js';
 import { isPromptLine, containsSpinnerOrWorkingIndicator, containsProcessingIndicator, containsBusyStatusBar, containsRewindMode, extractChatPrefix, stripTuiLineBorders, matchTuiPromptLine, } from '../../utils/terminal-string-ops.js';
@@ -1843,9 +1845,12 @@ export class AgentRegistrationService {
             // path — this branch used to spawn env-less, so every agent that came
             // through Step 2 ran without CREWLY_SESSION_NAME (unattributed heartbeats
             // and channel replies).
+            // API keys ride in the spawn env too (never typed in) — this path had no
+            // settings keys at all before, so a recreated agent ran without them.
             const recreationCwd = projectPath || process.cwd();
+            const recreationKeyEnv = await this.buildApiKeyEnv(runtimeType);
             await (await this.getSessionHelper()).createSession(sessionName, recreationCwd, {
-                env: this.buildAgentIdentityEnv(sessionName, role, recreationCwd, runtimeType),
+                env: { ...this.buildAgentIdentityEnv(sessionName, role, recreationCwd, runtimeType), ...recreationKeyEnv },
             });
             // D3: let the shell print its prompt before the init sequence's Ctrl-C.
             await this.waitForShellReady(sessionName);
@@ -2240,6 +2245,13 @@ export class AgentRegistrationService {
             // so the agent's reading order is "what am I on the hook for RIGHT
             // NOW" before the supplementary memory context. Soft-fail with WARN
             // — TaskPool/Request hiccups must not block agent boot.
+            //
+            // #816: both briefings are captured here and handed to the modular
+            // assembler below (ActiveWorkModule / SessionBriefingModule). The
+            // modular path returns its own prompt, so appending to `prompt`
+            // alone used to drop them on the default path.
+            let activeWorkBriefingMd;
+            let sessionBriefingMd;
             try {
                 // ActiveWorkBriefingService.getInstance() is async — see service
                 // JSDoc. Dynamic-import migration was the build-fix for PR #494's
@@ -2248,7 +2260,7 @@ export class AgentRegistrationService {
                 const activeWorkBriefing = await activeWorkService.generateActiveWorkBriefing(sessionName, role);
                 const activeWorkMd = activeWorkService.formatBriefingAsMarkdown(activeWorkBriefing);
                 if (activeWorkMd && activeWorkMd.length > 30) {
-                    prompt += `\n\n---\n\n${activeWorkMd}`;
+                    activeWorkBriefingMd = activeWorkMd;
                     this.logger.info('Active-work briefing injected into prompt', {
                         sessionName,
                         role,
@@ -2268,6 +2280,14 @@ export class AgentRegistrationService {
                     error: activeWorkError instanceof Error ? activeWorkError.message : String(activeWorkError),
                 });
             }
+            // Always emit the section: the briefing, or an explicit "not
+            // injected" notice, so the recovery protocol's "section above" is
+            // true on this (legacy, non-modular) path too.
+            prompt += `\n\n---\n\n${renderActiveWorkSection(activeWorkBriefingMd, {
+                agentSkillsPath: path.join(this.projectRoot, 'config', 'skills', 'agent'),
+                sessionName,
+                role,
+            })}`;
             // Generate and inject startup briefing from session memory
             try {
                 const sessionMemoryService = SessionMemoryService.getInstance();
@@ -2275,6 +2295,7 @@ export class AgentRegistrationService {
                 const briefing = await sessionMemoryService.generateStartupBriefing(sessionName, role, projectPath);
                 const briefingMd = sessionMemoryService.formatBriefingAsMarkdown(briefing);
                 if (briefingMd && briefingMd.length > 30) {
+                    sessionBriefingMd = briefingMd;
                     prompt += `\n\n---\n\n${briefingMd}`;
                     this.logger.info('Startup briefing injected into prompt', { sessionName, role, briefingLength: briefingMd.length });
                 }
@@ -2396,6 +2417,10 @@ export class AgentRegistrationService {
                         teamNormsPath,
                     };
                 }
+                // #816: startup state rides in the module config so the modular
+                // prompt carries it (ActiveWorkModule / SessionBriefingModule).
+                moduleConfig.activeWorkBriefing = activeWorkBriefingMd;
+                moduleConfig.sessionBriefing = sessionBriefingMd;
                 // Prompt tiering: the orchestrator is re-registered on every
                 // cold start and re-reads the whole system prompt at full price.
                 // CREWLY_ORC_PROMPT_PROFILE=lite drops the planning/onboarding
@@ -2785,9 +2810,11 @@ Loop until done, blocked, or explicitly reassigned:
             return;
         }
         // Create new session for orchestrator — with the identity env (D1), the
-        // same object the primary path spawns with. windowName not used in PTY backend.
+        // same object the primary path spawns with, plus the settings API keys in
+        // the spawn env (never typed in). windowName not used in PTY backend.
+        const apiKeyEnv = await this.buildApiKeyEnv(config.runtimeType ?? RUNTIME_TYPES.CLAUDE_CODE);
         await (await this.getSessionHelper()).createSession(config.sessionName, config.projectPath, {
-            env: this.buildAgentIdentityEnv(config.sessionName, ORCHESTRATOR_ROLE, config.projectPath, config.runtimeType),
+            env: { ...this.buildAgentIdentityEnv(config.sessionName, ORCHESTRATOR_ROLE, config.projectPath, config.runtimeType), ...apiKeyEnv },
         });
         this.logger.info('Orchestrator session created successfully', {
             sessionName: config.sessionName,
@@ -2828,6 +2855,57 @@ Loop until done, blocked, or explicitly reassigned:
             [ENV_CONSTANTS.CREWLY_INSTALL_DIR]: this.projectRoot,
         };
     }
+    /**
+     * The API-key environment for a PTY runtime, resolved from settings (with
+     * the per-runtime override chain).
+     *
+     * These are secrets, so they are only ever passed as the PTY's spawn
+     * environment (`createSession(..., { env })`), never typed in as `export`
+     * — a typed export is echoed by the shell into scrollback, the persistent
+     * session log and the terminal-output API.
+     *
+     * Used by the PTY runtimes (claude-code, gemini-cli, codex-cli,
+     * antigravity-cli, opencode-cli). crewly-agent gets its keys via
+     * CrewlyAgentExternalRuntimeService.buildChildEnv instead.
+     *
+     * Two runtimes get an override on top of the plain settings lookup, both
+     * carried over from the primary spawn path's inline key resolution:
+     * - Antigravity: a key already saved in Settings → Harness is applied at
+     *   spawn via buildAgentIdentityEnv (harnessEnvForAgents); a settings
+     *   Gemini key must not override it here.
+     * - Codex: it prefers OPENAI_API_KEY over its own login, so a stale
+     *   settings key overrides a working ChatGPT sign-in ("Incorrect API
+     *   key", Nova 2026-09-26). When Codex already has its own login, the
+     *   settings key is withheld.
+     *
+     * @param runtimeType - Runtime the session will run (selects key overrides)
+     * @returns Env entries for every key that is configured; empty when none are
+     */
+    async buildApiKeyEnv(runtimeType) {
+        const settingsService = getSettingsService();
+        const runtimeContext = { runtime: runtimeType };
+        const env = {};
+        // Gemini key — needed by gemini-cli. An Antigravity session whose key
+        // was saved in Settings → Harness already got it at spawn
+        // (buildAgentIdentityEnv); a settings key must not override it.
+        const antigravityKeyAtSpawn = runtimeType === RUNTIME_TYPES.ANTIGRAVITY_CLI && getHarnessCredentialsStore().getAntigravityGeminiApiKey() !== null;
+        const geminiKey = antigravityKeyAtSpawn ? undefined : await settingsService.getApiKey('gemini', runtimeContext);
+        if (geminiKey) {
+            env.GOOGLE_GENERATIVE_AI_API_KEY = geminiKey;
+            env[ENV_CONSTANTS.GEMINI_API_KEY] = geminiKey;
+        }
+        // Anthropic key — needed by claude-code
+        const anthropicKey = await settingsService.getApiKey('anthropic', runtimeContext);
+        if (anthropicKey)
+            env.ANTHROPIC_API_KEY = anthropicKey;
+        // OpenAI key — needed by codex-cli and opencode-cli. Skipped for Codex
+        // when it already has its own login (see docstring above).
+        const openaiKey = await settingsService.getApiKey('openai', runtimeContext);
+        if (openaiKey && !(runtimeType === RUNTIME_TYPES.CODEX_CLI && codexHasOwnLogin())) {
+            env.OPENAI_API_KEY = openaiKey;
+        }
+        return env;
+    }
     /**
      * Wait — bounded — for a freshly spawned shell to print its prompt before
      * anything is written to it.
@@ -3309,8 +3387,14 @@ Loop until done, blocked, or explicitly reassigned:
                 // CREWLY_SESSION_NAME — no X-Agent-Session header, and
                 // reply-channel fails with a misleading 404 (Think Tank, 2026-09-18).
                 // Same env object as the Step-2 recreation path (buildAgentIdentityEnv).
+                //
+                // API keys go ONLY into the spawn environment. They used to be typed
+                // in as `export KEY="…"`, which echoed the key into the PTY: it then
+                // sat in scrollback, in ~/.crewly/logs/sessions/*.log and in the
+                // terminal-output API. setEnvironmentVariable now refuses secrets.
+                const apiKeyEnv = await this.buildApiKeyEnv(runtimeType);
                 const createdSession = await sessionHelper.createSession(sessionName, cwdToUse, {
-                    env: this.buildAgentIdentityEnv(sessionName, role, cwdToUse, runtimeType),
+                    env: { ...this.buildAgentIdentityEnv(sessionName, role, cwdToUse, runtimeType), ...apiKeyEnv },
                 });
                 this.logger.info('PTY session created successfully', {
                     sessionName,
@@ -3359,36 +3443,12 @@ Loop until done, blocked, or explicitly reassigned:
             await sessionHelper.setEnvironmentVariable(sessionName, ENV_CONSTANTS.CREWLY_PROJECT_PATH, cwdToUse);
             // #222: Set install dir so agents can resolve skill paths regardless of CWD
             await sessionHelper.setEnvironmentVariable(sessionName, ENV_CONSTANTS.CREWLY_INSTALL_DIR, this.projectRoot);
-            // Inject API keys from settings (with override chain) for the PTY
-            // runtimes (claude-code, gemini-cli, codex-cli, opencode-cli). crewly-agent never
-            // reaches this block — it returns from the in-process branch above —
-            // and gets its keys via CrewlyAgentExternalRuntimeService.buildChildEnv
-            // on the child's spawn environment instead.
+            // API keys were passed in the spawn environment above (buildApiKeyEnv),
+            // never typed into the PTY. The Antigravity-harness-key and
+            // codex-has-own-login overrides that used to live here now live in
+            // buildApiKeyEnv() itself, since that is the only place keys are
+            // resolved for this (primary) spawn path.
             const settingsService = getSettingsService();
-            const runtimeContext = { runtime: runtimeType };
-            // Gemini key — needed by gemini-cli, antigravity-cli and crewly-agent.
-            // An Antigravity session whose key was saved in Settings → Harness
-            // already got it at spawn (buildAgentIdentityEnv); a settings key
-            // must not override it, and the saved key is never typed here.
-            const antigravityKeyAtSpawn = runtimeType === RUNTIME_TYPES.ANTIGRAVITY_CLI && getHarnessCredentialsStore().getAntigravityGeminiApiKey() !== null;
-            const geminiKey = antigravityKeyAtSpawn ? undefined : await settingsService.getApiKey('gemini', runtimeContext);
-            if (geminiKey) {
-                await sessionHelper.setEnvironmentVariable(sessionName, 'GOOGLE_GENERATIVE_AI_API_KEY', geminiKey);
-                await sessionHelper.setEnvironmentVariable(sessionName, ENV_CONSTANTS.GEMINI_API_KEY, geminiKey);
-            }
-            // Anthropic key — needed by claude-code and crewly-agent
-            const anthropicKey = await settingsService.getApiKey('anthropic', runtimeContext);
-            if (anthropicKey) {
-                await sessionHelper.setEnvironmentVariable(sessionName, 'ANTHROPIC_API_KEY', anthropicKey);
-            }
-            // OpenAI key — needed by codex-cli, opencode-cli and crewly-agent
-            const openaiKey = await settingsService.getApiKey('openai', runtimeContext);
-            // Codex prefers OPENAI_API_KEY over its own login, so a stale key in
-            // settings overrode a working ChatGPT sign-in ("Incorrect API key",
-            // Nova 2026-09-26). When codex has its own credentials, leave it be.
-            if (openaiKey && !(runtimeType === RUNTIME_TYPES.CODEX_CLI && codexHasOwnLogin())) {
-                await sessionHelper.setEnvironmentVariable(sessionName, 'OPENAI_API_KEY', openaiKey);
-            }
             // Token tracking telemetry — inject env vars for runtimes that need them
             const settings = await settingsService.getSettings();
             if (settings.general?.tokenTracking && runtimeType === RUNTIME_TYPES.CLAUDE_CODE) {
@@ -3576,6 +3636,9 @@ Loop until done, blocked, or explicitly reassigned:
         let releaseMutex;
         const currentDelivery = new Promise((r) => { releaseMutex = r; });
         this.sessionDeliveryMutex.set(sessionName, currentDelivery);
+        // No fresh-conversation / context-cap `/clear` may start while this
+        // message is on its way in (it would be wiped before it is read).
+        const endFreshDelivery = this.beginFreshDelivery(sessionName);
         if (previousDelivery) {
             this.logger.info('Waiting for in-flight delivery to complete before sending', {
                 sessionName,
@@ -3584,6 +3647,8 @@ Loop until done, blocked, or explicitly reassigned:
             await previousDelivery.catch(() => { });
         }
         try {
+            // A clear that was already running when this started finishes first.
+            await this.waitIfFreshClearing(sessionName);
             if (!message || typeof message !== 'string') {
                 return {
                     success: false,
@@ -3888,12 +3953,42 @@ Loop until done, blocked, or explicitly reassigned:
             };
         }
         finally {
+            endFreshDelivery();
             releaseMutex();
             if (this.sessionDeliveryMutex.get(sessionName) === currentDelivery) {
                 this.sessionDeliveryMutex.delete(sessionName);
             }
         }
     }
+    /**
+     * Mark a delivery to a session with the fresh-conversation service so no
+     * `/clear` starts during it. Never throws.
+     *
+     * @param sessionName - Session being written to
+     * @returns Function ending the mark
+     */
+    beginFreshDelivery(sessionName) {
+        try {
+            return FreshTaskConversationService.getInstance().beginDelivery(sessionName);
+        }
+        catch {
+            return () => undefined;
+        }
+    }
+    /**
+     * Wait (bounded) for a running fresh-conversation / context-cap clear of
+     * the session. Never throws.
+     *
+     * @param sessionName - Session about to be written to
+     */
+    async waitIfFreshClearing(sessionName) {
+        try {
+            await FreshTaskConversationService.getInstance().waitIfClearing(sessionName);
+        }
+        catch {
+            // Best-effort: delivery proceeds regardless.
+        }
+    }
     /**
      * Wait for an agent session to be at a ready prompt before sending messages.
      *