@renseiai/agentfactory-nextjs 0.8.0

package/dist/src/webhook/handlers/session-created.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Handle agent session 'create' events — new session initiated.
+ */
+import { NextResponse } from 'next/server';
+import type { LinearWebhookPayload } from '@renseiai/agentfactory-linear';
+import type { ResolvedWebhookConfig } from '../../types.js';
+import type { createLogger } from '@renseiai/agentfactory-server';
+export declare function handleSessionCreated(config: ResolvedWebhookConfig, payload: LinearWebhookPayload, rawPayload: Record<string, unknown>, log: ReturnType<typeof createLogger>): Promise<NextResponse | null>;
+//# sourceMappingURL=session-created.d.ts.map

package/dist/src/webhook/handlers/session-created.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-created.d.ts","sourceRoot":"","sources":["../../../../src/webhook/handlers/session-created.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC1C,OAAO,KAAK,EAAE,oBAAoB,EAAiB,MAAM,+BAA+B,CAAA;AAoBxF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AAS3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AAEjE,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,qBAAqB,EAC7B,OAAO,EAAE,oBAAoB,EAC7B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,GAAG,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,GACnC,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAuY9B"}

package/dist/src/webhook/handlers/session-created.js

@@ -0,0 +1,337 @@
+/**
+ * Handle agent session 'create' events — new session initiated.
+ */
+import { NextResponse } from 'next/server';
+import { TERMINAL_STATUSES, validateWorkTypeForStatus, WORK_TYPE_ALLOWED_STATUSES, STATUS_WORK_TYPE_MAP, getValidWorkTypesForStatus, buildFailureContextBlock, } from '@renseiai/agentfactory-linear';
+import { generateIdempotencyKey, isWebhookProcessed, storeSessionState, getSessionState, updateSessionStatus, dispatchWork, getWorkflowState, } from '@renseiai/agentfactory-server';
+import { emitActivity, determineWorkType, isProjectAllowed, getAppUrl, getPriority, WORK_TYPE_MESSAGES, } from '../utils.js';
+export async function handleSessionCreated(config, payload, rawPayload, log) {
+    const agentSession = rawPayload.agentSession;
+    log.debug('AgentSessionEvent payload structure', {
+        payloadKeys: Object.keys(rawPayload),
+        agentSessionKeys: agentSession ? Object.keys(agentSession) : [],
+        hasAgentSession: !!agentSession,
+    });
+    if (!agentSession) {
+        log.error('AgentSessionEvent missing agentSession field', {
+            payloadKeys: Object.keys(rawPayload),
+        });
+        return NextResponse.json({ error: 'Missing agentSession in webhook payload', success: false }, { status: 400 });
+    }
+    const sessionId = agentSession.id;
+    const issue = agentSession.issue;
+    const issueId = agentSession.issueId || issue?.id;
+    const webhookId = rawPayload.webhookId;
+    const agentId = agentSession.agentId;
+    if (!sessionId || !issueId) {
+        log.error('Missing sessionId or issueId in webhook payload', {
+            sessionId,
+            issueId,
+            agentSessionKeys: Object.keys(agentSession),
+        });
+        return NextResponse.json({ error: 'Invalid payload structure', success: false }, { status: 400 });
+    }
+    const sessionLog = log.child({ sessionId, issueId });
+    const promptContext = rawPayload.promptContext;
+    const user = rawPayload.user;
+    const comment = rawPayload.comment;
+    const isMention = !!comment;
+    const initiationType = isMention ? 'mention' : 'delegation';
+    sessionLog.info('Agent session created', {
+        initiationType,
+        isMention,
+        hasPromptContext: !!promptContext,
+        promptContextLength: promptContext?.length,
+        userName: user?.name,
+    });
+    // Idempotency check
+    const idempotencyKey = generateIdempotencyKey(webhookId, sessionId);
+    if (await isWebhookProcessed(idempotencyKey)) {
+        sessionLog.info('Duplicate webhook ignored', { idempotencyKey });
+        return NextResponse.json({ success: true, skipped: true, reason: 'duplicate_webhook' });
+    }
+    const existingSession = await getSessionState(sessionId);
+    if (existingSession) {
+        sessionLog.info('Session already exists', { status: existingSession.status });
+        return NextResponse.json({ success: true, skipped: true, reason: 'session_already_exists' });
+    }
+    const issueIdentifier = issue?.identifier || issueId.slice(0, 8);
+    // Determine work type
+    let workType = 'development';
+    let currentStatus;
+    let projectName;
+    let workTypeSource = 'status';
+    // Fetch current issue status
+    try {
+        const linearClient = await config.linearClient.getClient(payload.organizationId);
+        const issueDetails = await linearClient.getIssue(issueId);
+        const currentState = await issueDetails.state;
+        currentStatus = currentState?.name;
+        sessionLog.debug('Fetched current issue status', { currentStatus });
+        // Extract project name for routing
+        const project = await issueDetails.project;
+        projectName = project?.name;
+    }
+    catch (err) {
+        sessionLog.warn('Failed to fetch issue status', { error: err });
+    }
+    // Server-level project filter
+    if (!isProjectAllowed(projectName, config.projects ?? [])) {
+        sessionLog.debug('Project not handled by this server, skipping', { projectName });
+        return NextResponse.json({ success: true, skipped: true, reason: 'project_not_allowed' });
+    }
+    // Phase 1: Mention-based routing
+    if (isMention && promptContext && config.detectWorkTypeFromPrompt) {
+        // For mentions: unconstrained detection (pass all work types)
+        const allWorkTypes = [
+            'coordination', 'backlog-creation', 'research', 'qa', 'inflight',
+            'acceptance', 'refinement', 'development', 'qa-coordination', 'acceptance-coordination',
+        ];
+        const mentionWorkType = config.detectWorkTypeFromPrompt(promptContext, allWorkTypes);
+        if (mentionWorkType) {
+            workType = mentionWorkType;
+            workTypeSource = 'mention';
+            sessionLog.info('Detected work type from mention prompt', {
+                workType,
+                currentStatus,
+                promptPreview: promptContext.substring(0, 50),
+            });
+        }
+    }
+    // For non-mentions or when mention detection failed: constrained detection
+    if (workTypeSource === 'status' && promptContext && currentStatus && config.detectWorkTypeFromPrompt) {
+        const validWorkTypes = getValidWorkTypesForStatus(currentStatus);
+        const constrainedWorkType = config.detectWorkTypeFromPrompt(promptContext, validWorkTypes);
+        if (constrainedWorkType) {
+            workType = constrainedWorkType;
+            workTypeSource = 'mention';
+            sessionLog.info('Detected work type from promptContext (constrained)', {
+                workType,
+                currentStatus,
+                validWorkTypes,
+            });
+        }
+    }
+    // Phase 2: Fall back to status-based routing
+    if (workTypeSource === 'status') {
+        workType = determineWorkType(currentStatus);
+        sessionLog.info('Detected work type from issue status', {
+            currentStatus,
+            workType,
+        });
+    }
+    // Phase 2.5: Auto-detect parent/child issues for coordination routing
+    // Apply to all status-derived work types that have coordination variants
+    const coordinationUpgradeable = workTypeSource === 'status' && (workType === 'development' || workType === 'refinement');
+    if (coordinationUpgradeable) {
+        try {
+            const linearClient = await config.linearClient.getClient(payload.organizationId);
+            // Skip child/sub-issues for non-mention sessions — these are managed
+            // by the parent issue's coordinator agent, not dispatched independently.
+            if (workType === 'development') {
+                const isChild = await linearClient.isChildIssue(issueId);
+                if (isChild) {
+                    sessionLog.info('Sub-issue detected, skipping independent agent dispatch', {
+                        issueIdentifier,
+                    });
+                    try {
+                        await emitActivity(linearClient, sessionId, 'response', `This is a sub-issue. Work will be coordinated by the parent issue's agent.`);
+                    }
+                    catch (err) {
+                        sessionLog.warn('Failed to emit sub-issue skip activity', { error: err });
+                    }
+                    return NextResponse.json({
+                        success: true,
+                        skipped: true,
+                        reason: 'sub_issue_managed_by_parent',
+                    });
+                }
+            }
+            const isParent = await linearClient.isParentIssue(issueId);
+            if (isParent) {
+                if (workType === 'development')
+                    workType = 'coordination';
+                else if (workType === 'refinement')
+                    workType = 'refinement-coordination';
+                sessionLog.info('Parent issue detected, switching to coordination work type', {
+                    issueIdentifier,
+                    workType,
+                });
+            }
+        }
+        catch (err) {
+            sessionLog.warn('Failed to check issue parent/child status', { error: err });
+        }
+    }
+    // Check terminal state
+    if (currentStatus && TERMINAL_STATUSES.includes(currentStatus)) {
+        sessionLog.info('Issue in terminal state, acknowledging mention', { currentStatus });
+        try {
+            const linearClient = await config.linearClient.getClient(payload.organizationId);
+            await emitActivity(linearClient, sessionId, 'response', `This issue is in **${currentStatus}** status and has been completed. No further agent work is needed.\n\n` +
+                `If you need additional help, please create a new issue or reopen this one by moving it back to an active status.`);
+        }
+        catch (err) {
+            sessionLog.error('Failed to emit terminal state response', { error: err });
+        }
+        return NextResponse.json({ success: true, skipped: true, reason: 'terminal_state', currentStatus });
+    }
+    // Validate work type for status
+    if (currentStatus) {
+        const validation = validateWorkTypeForStatus(workType, currentStatus);
+        if (!validation.valid) {
+            sessionLog.warn('Work type validation failed', { workType, currentStatus, error: validation.error });
+            try {
+                const linearClient = await config.linearClient.getClient(payload.organizationId);
+                const allowedStatuses = WORK_TYPE_ALLOWED_STATUSES[workType];
+                const expectedWorkType = STATUS_WORK_TYPE_MAP[currentStatus];
+                await emitActivity(linearClient, sessionId, 'error', `Cannot perform ${workType} work on this issue.\n\n` +
+                    `**Current status:** ${currentStatus}\n` +
+                    `**${workType} requires status:** ${allowedStatuses.join(' or ')}\n\n` +
+                    (expectedWorkType
+                        ? `For issues in ${currentStatus} status, use ${expectedWorkType} commands instead.`
+                        : `This issue's status (${currentStatus}) is not handled by the agent.`));
+            }
+            catch (err) {
+                sessionLog.error('Failed to emit validation error activity', { error: err });
+            }
+            return NextResponse.json({
+                success: false,
+                error: 'work_type_invalid_for_status',
+                message: validation.error,
+            });
+        }
+    }
+    // Extract PR info for QA/acceptance agents so they know which PRs to validate
+    let prContext = '';
+    const needsPrContext = workType === 'qa' ||
+        workType === 'acceptance' ||
+        workType === 'qa-coordination' ||
+        workType === 'acceptance-coordination';
+    if (needsPrContext) {
+        try {
+            const linearClient = await config.linearClient.getClient(payload.organizationId);
+            const issueForAttachments = await linearClient.getIssue(issueId);
+            const attachments = await issueForAttachments.attachments();
+            const prLinks = attachments.nodes
+                .filter((a) => a.url?.includes('github.com') && a.url?.includes('/pull/'))
+                .map((a) => {
+                const match = a.url.match(/\/pull\/(\d+)/);
+                return match ? { url: a.url, number: parseInt(match[1], 10), title: a.title ?? '' } : null;
+            })
+                .filter((pr) => pr !== null);
+            if (prLinks.length > 0) {
+                prContext = '\n\nLinked PRs:\n';
+                prContext += prLinks.map((pr) => `- PR #${pr.number}: ${pr.title} (${pr.url})`).join('\n');
+                if (prLinks.length > 1) {
+                    prContext +=
+                        '\n\nNote: Multiple PRs are linked. Check each PR state (open/merged/closed) and validate the most recent OPEN one.';
+                }
+            }
+            sessionLog.debug('Extracted PR context for QA/acceptance', {
+                prLinksCount: prLinks.length,
+                hasPrContext: prContext.length > 0,
+            });
+        }
+        catch (err) {
+            sessionLog.warn('Failed to extract PR info from issue attachments', { error: err });
+        }
+    }
+    const enhancedPromptContext = prContext
+        ? promptContext
+            ? promptContext + prContext
+            : prContext
+        : promptContext;
+    const priority = getPriority(config, workType);
+    await storeSessionState(sessionId, {
+        issueId,
+        issueIdentifier,
+        providerSessionId: null,
+        worktreePath: '',
+        status: 'pending',
+        queuedAt: Date.now(),
+        promptContext: promptContext,
+        priority,
+        organizationId: payload.organizationId,
+        workType,
+        agentId,
+        projectName,
+    });
+    // Enrich prompt with workflow failure context for retries
+    // Applies to: refinement, development (rework from Backlog), coordination (rework from Started)
+    let workflowContextBlock = '';
+    let wfContext;
+    const needsFailureContext = workType === 'refinement' || workType === 'refinement-coordination' ||
+        (workType === 'development' && currentStatus === 'Backlog') ||
+        (workType === 'coordination' && currentStatus === 'Started');
+    if (needsFailureContext) {
+        try {
+            const workflowState = await getWorkflowState(issueId);
+            if (workflowState && workflowState.cycleCount > 0) {
+                wfContext = {
+                    cycleCount: workflowState.cycleCount,
+                    strategy: workflowState.strategy,
+                    failureSummary: workflowState.failureSummary,
+                };
+                workflowContextBlock = buildFailureContextBlock(workType, wfContext);
+                if (workflowContextBlock) {
+                    sessionLog.info('Prompt enriched with workflow failure context', {
+                        workType,
+                        cycleCount: workflowState.cycleCount,
+                        strategy: workflowState.strategy,
+                    });
+                }
+            }
+        }
+        catch (err) {
+            sessionLog.warn('Failed to enrich prompt with workflow context', { error: err });
+        }
+    }
+    // Queue work
+    const work = {
+        sessionId,
+        issueId,
+        issueIdentifier,
+        priority,
+        queuedAt: Date.now(),
+        workType,
+        prompt: config.generatePrompt(issueIdentifier, workType, enhancedPromptContext, wfContext) + workflowContextBlock,
+        projectName,
+    };
+    const result = await dispatchWork(work);
+    if (result.dispatched || result.parked) {
+        sessionLog.info('Work dispatched', {
+            sessionId,
+            issueIdentifier,
+            workType,
+            dispatched: result.dispatched,
+            parked: result.parked,
+            replaced: result.replaced,
+        });
+    }
+    else {
+        sessionLog.error('Failed to dispatch work');
+        await updateSessionStatus(sessionId, 'failed');
+    }
+    // Update session with externalUrl and acknowledge
+    try {
+        const linearClient = await config.linearClient.getClient(payload.organizationId);
+        const appUrl = getAppUrl(config);
+        await linearClient.updateAgentSession({
+            sessionId,
+            externalUrls: [
+                {
+                    label: 'Agent Dashboard',
+                    url: `${appUrl}/sessions/${sessionId}`,
+                },
+            ],
+        });
+        const activityText = WORK_TYPE_MESSAGES[workType];
+        await emitActivity(linearClient, sessionId, 'thought', activityText);
+        sessionLog.debug('Session updated and activity emitted');
+    }
+    catch (err) {
+        sessionLog.error('Failed to update session or create comment', { error: err });
+    }
+    return null; // Continue processing
+}

package/dist/src/webhook/handlers/session-prompted.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Handle agent session 'prompted' events — follow-up messages or stop/continue signals.
+ */
+import { NextResponse } from 'next/server';
+import type { LinearWebhookPayload } from '@renseiai/agentfactory-linear';
+import type { ResolvedWebhookConfig } from '../../types.js';
+import type { createLogger } from '@renseiai/agentfactory-server';
+export declare function handleSessionPrompted(config: ResolvedWebhookConfig, payload: LinearWebhookPayload, rawPayload: Record<string, unknown>, log: ReturnType<typeof createLogger>): Promise<NextResponse | null>;
+//# sourceMappingURL=session-prompted.d.ts.map

package/dist/src/webhook/handlers/session-prompted.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-prompted.d.ts","sourceRoot":"","sources":["../../../../src/webhook/handlers/session-prompted.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC1C,OAAO,KAAK,EAAE,oBAAoB,EAAiB,MAAM,+BAA+B,CAAA;AAaxF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AAE3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AAEjE,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,qBAAqB,EAC7B,OAAO,EAAE,oBAAoB,EAC7B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,GAAG,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,GACnC,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAoP9B"}

package/dist/src/webhook/handlers/session-prompted.js

@@ -0,0 +1,199 @@
+/**
+ * Handle agent session 'prompted' events — follow-up messages or stop/continue signals.
+ */
+import { NextResponse } from 'next/server';
+import { getSessionState, updateSessionStatus, storeSessionState, releaseClaim, removeWorkerSession, dispatchWork, storePendingPrompt, generateIdempotencyKey, isWebhookProcessed, } from '@renseiai/agentfactory-server';
+import { handleStopSignal, emitActivity } from '../utils.js';
+export async function handleSessionPrompted(config, payload, rawPayload, log) {
+    const agentSession = rawPayload.agentSession;
+    if (!agentSession) {
+        log.warn('AgentSessionEvent prompted missing agentSession field');
+        return NextResponse.json({ success: true, skipped: true, reason: 'missing_agent_session' });
+    }
+    const sessionId = agentSession.id;
+    const issue = agentSession.issue;
+    const issueId = agentSession.issueId || issue?.id;
+    const promptText = rawPayload.promptContext || '';
+    const webhookId = rawPayload.webhookId;
+    const user = rawPayload.user;
+    const agentActivity = rawPayload.agentActivity;
+    const comment = rawPayload.comment;
+    const commentBody = comment?.body || '';
+    const promptLog = log.child({ sessionId, issueId });
+    // Check for stop/continue signals
+    const activitySignal = agentActivity?.signal;
+    const isStopSignal = activitySignal === 'stop';
+    const isContinueSignal = activitySignal === 'continue';
+    promptLog.info('Agent session prompted', {
+        hasPromptContext: !!promptText,
+        promptContextLength: promptText?.length,
+        userName: user?.name,
+        hasAgentActivity: !!agentActivity,
+        activitySignal,
+        isStopSignal,
+        isContinueSignal,
+        hasComment: !!comment,
+        commentBodyLength: commentBody?.length,
+    });
+    // Handle stop signal
+    if (isStopSignal) {
+        promptLog.info('Stop signal received via prompted webhook');
+        await handleStopSignal(config, sessionId, issueId, payload.organizationId);
+        return NextResponse.json({ success: true, action: 'stopped', sessionId });
+    }
+    // Handle continue signal
+    if (isContinueSignal) {
+        promptLog.info('Continue signal received via prompted webhook');
+        const existingSession = await getSessionState(sessionId);
+        const workType = existingSession?.workType || 'inflight';
+        let resumePrompt = promptText || commentBody || '';
+        const issueIdentifier = existingSession?.issueIdentifier ||
+            issue?.identifier ||
+            issueId.slice(0, 8);
+        promptLog.info('Session state for continue', {
+            hasExistingSession: !!existingSession,
+            sessionStatus: existingSession?.status,
+            workType,
+        });
+        if (!resumePrompt.trim()) {
+            resumePrompt = config.generatePrompt(issueIdentifier, workType);
+        }
+        // Reset session status if in terminal state
+        if (existingSession && ['completed', 'failed', 'stopped'].includes(existingSession.status)) {
+            await releaseClaim(sessionId);
+            if (existingSession.workerId) {
+                await removeWorkerSession(existingSession.workerId, sessionId);
+            }
+            await updateSessionStatus(sessionId, 'pending');
+        }
+        // Update organizationId if missing
+        if (existingSession && !existingSession.organizationId && payload.organizationId) {
+            await storeSessionState(sessionId, {
+                ...existingSession,
+                organizationId: payload.organizationId,
+                status: 'pending',
+            });
+        }
+        // Queue work to resume
+        const work = {
+            sessionId,
+            issueId,
+            issueIdentifier,
+            priority: 2,
+            queuedAt: Date.now(),
+            prompt: resumePrompt,
+            providerSessionId: existingSession?.providerSessionId || undefined,
+            workType,
+            projectName: existingSession?.projectName,
+        };
+        await dispatchWork(work);
+        try {
+            const linearClient = await config.linearClient.getClient(payload.organizationId);
+            await emitActivity(linearClient, sessionId, 'thought', 'Session resume requested. Waiting for an available worker...');
+        }
+        catch (err) {
+            promptLog.error('Failed to emit continue acknowledgment activity', { error: err });
+        }
+        return NextResponse.json({ success: true, action: 'continue_queued', sessionId });
+    }
+    // Generate idempotency key for prompted events
+    const idempotencyKey = generateIdempotencyKey(webhookId, `${sessionId}:prompt:${payload.createdAt}`);
+    if (await isWebhookProcessed(idempotencyKey)) {
+        promptLog.info('Duplicate prompted webhook ignored', { idempotencyKey });
+        return NextResponse.json({ success: true, skipped: true, reason: 'duplicate_prompt' });
+    }
+    const existingSession = await getSessionState(sessionId);
+    const issueIdentifier = existingSession?.issueIdentifier ||
+        issue?.identifier ||
+        issueId.slice(0, 8);
+    // Determine effective prompt with cascading fallbacks
+    let effectivePrompt = promptText.trim();
+    if (!effectivePrompt && commentBody.trim()) {
+        effectivePrompt = commentBody.trim();
+        promptLog.info('Using comment body as prompt fallback');
+    }
+    if (!effectivePrompt) {
+        if (existingSession) {
+            effectivePrompt = config.generatePrompt(issueIdentifier, existingSession.workType || 'inflight');
+            promptLog.info('Generated continue prompt for empty prompt');
+        }
+        else {
+            promptLog.warn('Empty prompt with no existing session, skipping');
+            return NextResponse.json({ success: true, skipped: true, reason: 'empty_prompt_no_session' });
+        }
+    }
+    // If session is running, store as pending prompt
+    if (existingSession?.status === 'running' || existingSession?.status === 'claimed') {
+        const userInfo = user ? {
+            id: user.id,
+            name: user.name,
+        } : undefined;
+        const pendingPrompt = await storePendingPrompt(sessionId, issueId, effectivePrompt, userInfo);
+        if (pendingPrompt) {
+            promptLog.info('Pending prompt stored for running session', {
+                promptId: pendingPrompt.id,
+                sessionId,
+                issueIdentifier,
+                workerId: existingSession.workerId,
+            });
+        }
+        else {
+            promptLog.error('Failed to store pending prompt');
+        }
+    }
+    else {
+        // Session not running — queue as work
+        promptLog.info('Queuing follow-up for non-running session', {
+            sessionStatus: existingSession?.status,
+        });
+        if (existingSession && ['completed', 'failed', 'stopped'].includes(existingSession.status)) {
+            await releaseClaim(sessionId);
+            if (existingSession.workerId) {
+                await removeWorkerSession(existingSession.workerId, sessionId);
+            }
+            await updateSessionStatus(sessionId, 'pending');
+        }
+        if (existingSession && !existingSession.organizationId && payload.organizationId) {
+            await storeSessionState(sessionId, {
+                ...existingSession,
+                organizationId: payload.organizationId,
+                status: 'pending',
+            });
+        }
+        const work = {
+            sessionId,
+            issueId,
+            issueIdentifier,
+            priority: 2,
+            queuedAt: Date.now(),
+            prompt: effectivePrompt,
+            providerSessionId: existingSession?.providerSessionId || undefined,
+            workType: existingSession?.workType || 'inflight',
+            projectName: existingSession?.projectName,
+        };
+        const dispatchResult = await dispatchWork(work);
+        if (dispatchResult.dispatched || dispatchResult.parked) {
+            promptLog.info('Follow-up prompt dispatched', {
+                sessionId,
+                issueIdentifier,
+                dispatched: dispatchResult.dispatched,
+                parked: dispatchResult.parked,
+            });
+        }
+        else {
+            promptLog.error('Failed to dispatch follow-up prompt');
+        }
+    }
+    // Acknowledge prompt receipt
+    try {
+        const linearClient = await config.linearClient.getClient(payload.organizationId);
+        const truncatedPrompt = effectivePrompt.length > 100
+            ? `${effectivePrompt.substring(0, 100)}...`
+            : effectivePrompt;
+        await emitActivity(linearClient, sessionId, 'thought', `Follow-up received: "${truncatedPrompt}" - Processing...`);
+    }
+    catch (err) {
+        promptLog.error('Failed to emit prompt acknowledgment activity', { error: err });
+    }
+    return null; // Continue processing
+}

package/dist/src/webhook/handlers/session-updated.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Handle agent session 'update' events — stop signal from user.
+ */
+import { NextResponse } from 'next/server';
+import type { LinearWebhookPayload } from '@renseiai/agentfactory-linear';
+import type { ResolvedWebhookConfig } from '../../types.js';
+import type { createLogger } from '@renseiai/agentfactory-server';
+export declare function handleSessionUpdated(config: ResolvedWebhookConfig, payload: LinearWebhookPayload, rawPayload: Record<string, unknown>, log: ReturnType<typeof createLogger>): Promise<NextResponse | null>;
+//# sourceMappingURL=session-updated.d.ts.map

package/dist/src/webhook/handlers/session-updated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-updated.d.ts","sourceRoot":"","sources":["../../../../src/webhook/handlers/session-updated.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC1C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAA;AACzE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AAE3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AAEjE,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,qBAAqB,EAC7B,OAAO,EAAE,oBAAoB,EAC7B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,GAAG,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,GACnC,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CA6B9B"}

package/dist/src/webhook/handlers/session-updated.js

@@ -0,0 +1,29 @@
+/**
+ * Handle agent session 'update' events — stop signal from user.
+ */
+import { NextResponse } from 'next/server';
+import { handleStopSignal } from '../utils.js';
+export async function handleSessionUpdated(config, payload, rawPayload, log) {
+    const agentSession = rawPayload.agentSession;
+    if (!agentSession) {
+        log.warn('AgentSessionEvent updated missing agentSession field');
+        return NextResponse.json({ success: true, skipped: true, reason: 'missing_agent_session' });
+    }
+    const sessionId = agentSession.id;
+    const issue = agentSession.issue;
+    const issueId = agentSession.issueId || issue?.id;
+    const newState = agentSession.state;
+    const updatedFrom = rawPayload.updatedFrom;
+    const previousState = updatedFrom?.state;
+    const updateLog = log.child({ sessionId, issueId });
+    updateLog.info('Agent session updated', {
+        newState,
+        previousState,
+    });
+    // Check if this is a stop signal (state changed to completed/failed)
+    if (newState === 'completed' || newState === 'failed') {
+        updateLog.info('Stop signal received via updated webhook', { previousState });
+        await handleStopSignal(config, sessionId, issueId, payload.organizationId);
+    }
+    return null; // Continue processing other handlers
+}

package/dist/src/webhook/processor.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Webhook Processor — Main Entry Point
+ *
+ * Receives Linear webhook events, verifies signatures, runs idempotency
+ * checks, and dispatches to sub-handlers.
+ */
+import { NextRequest, NextResponse } from 'next/server';
+import type { ResolvedWebhookConfig } from '../types.js';
+/**
+ * Create webhook route handlers from config.
+ *
+ * Returns { POST, GET } for use as Next.js App Router exports.
+ */
+export declare function createWebhookHandler(config: ResolvedWebhookConfig): {
+    POST: (request: NextRequest) => Promise<NextResponse<unknown>>;
+    GET: () => Promise<NextResponse<{
+        status: string;
+        endpoint: string;
+        description: string;
+    }>>;
+};
+//# sourceMappingURL=processor.d.ts.map

package/dist/src/webhook/processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processor.d.ts","sourceRoot":"","sources":["../../../src/webhook/processor.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AASvD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AASxD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,qBAAqB;oBACnC,WAAW;;;;;;EA2FzC"}