crewly 1.20.153 → 1.20.155

package/dist/backend/backend/src/index.js

@@ -55,11 +55,14 @@ import { RequestDecomposeSubscriber, setRequestDecomposeSubscriber, } from './se
 import { RequestStatusUpdateSubscriber } from './services/v3/request-status-update.subscriber.js';
 import { RequestCascadeSubscriber } from './services/v3/request-cascade.subscriber.js';
 import { setRequestServiceEventBus, RequestService } from './services/v3/request.service.js';
+import { OwnerReceiptService, setOwnerReceiptService } from './services/v3/owner-receipt/owner-receipt.service.js';
+import { createSlackOwnerSender, startOwnerReceiptSchedule, teamIndexOf, teamLeadIndexOf } from './services/v3/owner-receipt/owner-receipt.boot.js';
+import { IntakeOutcomeLog } from './services/v3/ticket-intake-log.js';
 import { getSlackService } from './services/slack/slack.service.js';
 import { getSlackTypingPlaceholderService } from './services/slack/slack-typing-placeholder.service.js';
 import { sendBootAnnouncement, isFirstBoot, markBooted } from './services/boot/boot-announce.service.js';
 import { SubAgentMessageQueue } from './services/messaging/sub-agent-message-queue.service.js';
-import { SUB_AGENT_QUEUE_CONSTANTS, CHAT_CONTEXT_CONSTANTS, SAFE_RESTART, AUTO_UPDATE_CONSTANTS, PROCESS_EXIT_CODES, CLAUDE_STARTUP_CONSTANTS, WEB_CONSTANTS, TICKET_CONSTANTS, UNASSIGNED_ROUTE_CONSTANTS, CLOUD_TALK_CONSTANTS } from './constants.js';
+import { SUB_AGENT_QUEUE_CONSTANTS, CHAT_CONTEXT_CONSTANTS, SAFE_RESTART, AUTO_UPDATE_CONSTANTS, PROCESS_EXIT_CODES, CLAUDE_STARTUP_CONSTANTS, WEB_CONSTANTS, TICKET_CONSTANTS, UNASSIGNED_ROUTE_CONSTANTS, CLOUD_TALK_CONSTANTS, STANDING_ANSWERS_CONSTANTS } from './constants.js';
 import { PtyActivityTrackerService } from './services/agent/pty-activity-tracker.service.js';
 import { InFlightTurnTracker } from './services/restart/in-flight-turn-tracker.service.js';
 import { TicketIntakeService, setTicketIntakeService, resolveTicketIdForSession, } from './services/v3/ticket-intake.service.js';
@@ -85,7 +88,7 @@ import { setMessageQueueService as setMessagingControllerQueueService } from './
 import { SystemResourceAlertService } from './services/monitoring/system-resource-alert.service.js';
 import { TokenUsageService } from './services/monitoring/token-usage.service.js';
 import { agentHeartbeatMiddleware } from './middleware/agent-heartbeat.middleware.js';
-import { apiTokenMiddleware, socketIoAllowRequest, installWebSocketGate, } from './middleware/api-token.middleware.js';
+import { apiTokenMiddleware, healthGateMiddleware, socketIoAllowRequest, installWebSocketGate, } from './middleware/api-token.middleware.js';
 import { resolveApiToken } from './services/core/api-token.service.js';
 import { isHeadlessEnvironment, describeNetworkExposure } from './utils/network-exposure.utils.js';
 import { RedisCacheService } from './services/cache/redis-cache.service.js';
@@ -125,6 +128,8 @@ import { FissionGuardService, createFailOpenBudgetChecker } from './services/fis
 import { BudgetService } from './services/autonomous/budget.service.js';
 import { setFissionGuardService } from './controllers/fission/fission.controller.js';
 import { TaskPoolService } from './services/task-pool/task-pool.service.js';
+import { WorkItemWorktreeService } from './services/worktree/workitem-worktree.service.js';
+import { WorkItemWorktreeSubscriber, createTerminalNotifier } from './services/worktree/workitem-worktree.subscriber.js';
 import { sessionsToRestore } from './services/agent/restore-filter.js';
 import { ProjectMemoryService } from './services/memory/project-memory.service.js';
 import { TaskHistorySubscriber } from './services/memory/task-history.subscriber.js';
@@ -385,6 +390,37 @@ export class CrewlyServer {
             taskPoolService: TaskPoolService.getInstance(),
         });
         taskHistorySubscriber.start();
+        // Per-WorkItem git worktrees (#814): observes WorkItem events only
+        // (no status writes). Opt-in per project (Project.worktrees = 'on');
+        // Team.worktrees = 'off' and CREWLY_WORKTREES=off opt out.
+        try {
+            const pool = TaskPoolService.getInstance();
+            const worktreeService = new WorkItemWorktreeService({ pool, storage: this.storageService, notify: createTerminalNotifier() });
+            const worktreeSubscriber = new WorkItemWorktreeSubscriber({
+                service: worktreeService,
+                events: this.eventBusService,
+                pool,
+            });
+            worktreeSubscriber.start();
+            // So the FIRST [CREWLY-DISPATCH] brief can already name the workdir
+            // (git worktree add can take seconds — long enough for a separate,
+            // later "worktree ready" message to arrive after the agent has
+            // already started in the shared checkout; #829 review).
+            void import('./services/v3/workitem-dispatch.subscriber.js')
+                .then(({ WorkItemDispatchSubscriber }) => {
+                WorkItemDispatchSubscriber.getInstance().setWorktreeHintResolver(worktreeService);
+            })
+                .catch((err) => {
+                this.logger.warn('Could not wire worktree hints into WorkItemDispatchSubscriber (non-fatal)', {
+                    error: err.message,
+                });
+            });
+        }
+        catch (worktreeErr) {
+            this.logger.warn('Per-WorkItem worktrees failed to start (non-fatal)', {
+                error: worktreeErr.message,
+            });
+        }
         // P1 Bug B (Pool umbrella WI 72ca743a): Wire RequestService into the
         // TaskPool singleton so addToPool intrinsically links new WIs into
         // their parent Request.workItemIds[] — independent of the
@@ -409,9 +445,12 @@ export class CrewlyServer {
         // Failure-isolated: tickets are an addition — messages are delivered
         // whether or not this is wired.
         try {
+            // #828 coverage: every owner message's fate, for the receipt's coverage line.
+            const intakeOutcomeLog = new IntakeOutcomeLog(RequestService.getInstance().getRequestsDir());
             const ticketIntake = new TicketIntakeService({
                 requests: RequestService.getInstance(),
                 findWorkItem: (id) => TaskPoolService.getInstance().findWorkItem(id),
+                outcomeLog: intakeOutcomeLog,
             });
             ticketIntake.setReceiptSink('chat-v2', createChatV2ReceiptSink({
                 chat: {
@@ -432,6 +471,21 @@ export class CrewlyServer {
                 },
             }));
             setTicketIntakeService(ticketIntake);
+            // #828: the owner's nightly receipt — built from tickets + WorkItems,
+            // DMed at his local time (default 21:00, can be turned off), and the
+            // same data at GET /api/owner-receipt for the dashboard.
+            {
+                const receipt = new OwnerReceiptService({
+                    listRequests: () => RequestService.getInstance().listAll(),
+                    listWorkItems: () => TaskPoolService.getInstance().getAllItems(),
+                    loadTeamIndex: async () => teamIndexOf(await StorageService.getInstance().getTeams()),
+                    loadTeamLeadIndex: async () => teamLeadIndexOf(await StorageService.getInstance().getTeams()),
+                    sender: createSlackOwnerSender(() => getSlackService()),
+                    readIntakeLog: () => intakeOutcomeLog.read(),
+                });
+                setOwnerReceiptService(receipt);
+                startOwnerReceiptSchedule(receipt);
+            }
             TaskPoolService.getInstance().setTicketResolver((sessionName) => resolveTicketIdForSession(InFlightTurnTracker.getInstance(), sessionName));
             // Phase 2: answered → 待验收 → 验过了 / 打回 / silence accepts.
             const ticketReview = new TicketReviewService({
@@ -692,6 +746,36 @@ export class CrewlyServer {
                     error: reflectErr.message,
                 });
             }
+            try {
+                // Standing-answer refresh (#816) on the reflect cadence: raise a
+                // refresh WorkItem for a standing page only when the memory
+                // behind it has moved. No LLM here; the WorkItem's agent writes.
+                // Agent pages are only checked for members that are active, so a
+                // stopped agent is never woken for its own page.
+                // CREWLY_STANDING_REFRESH=false disables it.
+                if (process.env['CREWLY_STANDING_REFRESH'] !== 'false') {
+                    const { StandingRefreshService } = await import('./services/memory/standing-refresh.service.js');
+                    const { resolveWikiOwner } = await import('./services/wiki/wiki-owner.resolver.js');
+                    const standingRefresh = new StandingRefreshService({
+                        pool: TaskPoolService.getInstance(),
+                        agentSkillsPath: path.join(findPackageRoot(__dirname), 'config', 'skills', 'agent'),
+                        listProjects: async () => (await this.storageService.getProjects()).map((p) => p.path).filter(Boolean),
+                        listAgents: async () => (await this.storageService.getTeams())
+                            .flatMap((t) => t.members ?? [])
+                            .filter((m) => m.agentStatus === CREWLY_CONSTANTS.AGENT_STATUSES.ACTIVE && m.sessionName)
+                            .map((m) => m.sessionName),
+                        resolveProjectTarget: (projectPath) => resolveWikiOwner(this.storageService, projectPath),
+                    });
+                    // Same cadence as the reflect trigger above.
+                    const reflectEvery = Number(process.env['CREWLY_WIKI_REFLECT_INTERVAL_MS']);
+                    standingRefresh.start(reflectEvery > 0 ? reflectEvery : STANDING_ANSWERS_CONSTANTS.REFRESH_INTERVAL_MS);
+                }
+            }
+            catch (standingErr) {
+                this.logger.warn('Standing-answer refresh failed to start (non-fatal)', {
+                    error: standingErr.message,
+                });
+            }
             // Daily memory consolidation (self-improvement wiring): the
             // MemoryConsolidationService existed but nothing ever called
             // consolidate(), so no agent ever had a consolidation.json. Run it
@@ -1282,15 +1366,18 @@ export class CrewlyServer {
     }
     configureRoutes() {
         // API token gate — loopback callers (local skills, local dashboard)
-        // pass; every other address must present the API token. `/health`,
-        // static assets and the SPA shell are outside `/api` and stay open.
+        // pass; every other address must present the API token. Static assets
+        // and the SPA shell are outside `/api` and stay open; `/health` has its
+        // own gate below (#825).
         this.app.use('/api', apiTokenMiddleware);
         // Agent heartbeat middleware - any API call with X-Agent-Session header updates heartbeat
         this.app.use('/api', agentHeartbeatMiddleware);
         // API routes
         this.app.use('/api', createApiRoutes(this.apiController));
-        // Health check (enhanced with mode and agent info)
-        this.app.get('/health', (req, res) => {
+        // Health check (enhanced with mode and agent info).
+        // #825: non-loopback callers need the API token (or CREWLY_PUBLIC_HEALTH=1);
+        // loopback reaches this handler exactly as before.
+        this.app.get('/health', healthGateMiddleware, (req, res) => {
             const versionService = VersionCheckService.getInstance();
             const cachedCheck = versionService.getCachedCheckResult();
             // Count active agents from the session backend.
@@ -2423,7 +2510,7 @@ export class CrewlyServer {
                             const taskPool = TaskPoolService.getInstance();
                             // Append system note to description so Agent knows why it was woken
                             const wakeNote = `\n\n[SYSTEM NOTE] Woken automatically by Trigger '${triggerId}' at ${new Date().toISOString()}.`;
-                            await taskPool.updateItemStatus(action.wakeWorkItemId, 'queued');
+                            await taskPool.updateItemStatus(action.wakeWorkItemId, 'queued', { role: 'system', via: 'trigger-wake' });
                             // Append wake reason to WorkItem description via storage
                             try {
                                 const item = (await taskPool.getAllItems()).find(wi => wi.id === action.wakeWorkItemId);
@@ -2549,6 +2636,19 @@ export class CrewlyServer {
                     error: dispatchErr instanceof Error ? dispatchErr.message : String(dispatchErr),
                 });
             }
+            // Idle-boundary context cap for Claude Code members: a long single
+            // task keeps growing its conversation (sessions at 650k–965k per
+            // turn); between turns, save + clear + re-orient it past the cap
+            // (CREWLY_MEMBER_CONTEXT_CAP_TOKENS, default 300k, 0 disables).
+            try {
+                const { FreshTaskConversationService } = await import('./services/agent/fresh-task-conversation.service.js');
+                FreshTaskConversationService.getInstance().startContextCapSweep();
+            }
+            catch (capErr) {
+                this.logger.warn('Member context-cap sweep failed to start (non-critical)', {
+                    error: capErr instanceof Error ? capErr.message : String(capErr),
+                });
+            }
             // Bootstrap SOPService at boot (F8 — fix/f8-get-sops-graceful-fallback).
             // This materialises `~/.crewly/sops/{system,custom}/` and seeds the
             // `index.json` so the get-sops skill — which sits on every agent's
@@ -2573,6 +2673,12 @@ export class CrewlyServer {
                 autoClaimService.initialize(this.eventBusService);
                 await autoClaimService.start();
                 this.logger.info('AgentAutoClaimService started — idle agents will auto-claim work');
+                // Project tickets (specs/2026-09-28-project-tickets.md): wire the
+                // workflow singleton (claim / assign / AutoClaim fallback) and keep
+                // tickets in step with their WorkItems — pool events plus a sweep.
+                const { projectTicketWorkflow } = await import('./controllers/project-tickets/project-tickets.controller.js');
+                projectTicketWorkflow().start(this.eventBusService);
+                this.logger.info('Project ticket workflow started — tickets follow their WorkItems');
             }
             catch (autoClaimErr) {
                 this.logger.warn('AgentAutoClaimService initialization failed (non-critical)', {