@renseiai/agentfactory-nextjs 0.8.0

package/dist/src/handlers/sessions/claim.js

@@ -0,0 +1,139 @@
+/**
+ * POST /api/sessions/[id]/claim
+ *
+ * Claim a session for processing.
+ * Uses atomic operations to prevent race conditions.
+ */
+import { NextResponse } from 'next/server';
+import { requireWorkerAuth } from '../../middleware/worker-auth.js';
+import { claimWork, requeueWork, releaseClaim, claimSession, getSessionState, addWorkerSession, getWorker, createLogger, } from '@renseiai/agentfactory-server';
+const log = createLogger('api:sessions:claim');
+export function createSessionClaimHandler() {
+    return async function POST(request, { params }) {
+        const authError = requireWorkerAuth(request);
+        if (authError)
+            return authError;
+        const { id: sessionId } = await params;
+        try {
+            const body = await request.json();
+            const { workerId } = body;
+            if (!workerId || typeof workerId !== 'string') {
+                return NextResponse.json({ error: 'Bad Request', message: 'workerId is required' }, { status: 400 });
+            }
+            const work = await claimWork(sessionId, workerId);
+            if (!work) {
+                log.debug('Failed to claim work from queue', { sessionId, workerId });
+                return NextResponse.json({
+                    claimed: false,
+                    reason: 'Work item not available or already claimed',
+                });
+            }
+            // Validate project routing: reject if the worker's project list
+            // doesn't include this work item's project. Prevents cross-repo
+            // execution when work is claimed by the wrong worker.
+            if (work.projectName) {
+                const worker = await getWorker(workerId);
+                if (worker?.projects && worker.projects.length > 0) {
+                    if (!worker.projects.includes(work.projectName)) {
+                        log.error('Project mismatch on claim — requeuing', {
+                            sessionId,
+                            workerId,
+                            workProject: work.projectName,
+                            workerProjects: worker.projects,
+                        });
+                        await requeueWork(work);
+                        return NextResponse.json({
+                            claimed: false,
+                            reason: `Worker not authorized for project ${work.projectName}`,
+                        });
+                    }
+                }
+            }
+            let claimSucceeded = false;
+            try {
+                const claimed = await claimSession(sessionId, workerId);
+                if (!claimed) {
+                    const sessionState = await getSessionState(sessionId);
+                    if (!sessionState) {
+                        log.warn('Session state expired, dropping orphaned work item', {
+                            sessionId,
+                            workerId,
+                            issueIdentifier: work.issueIdentifier,
+                        });
+                        await releaseClaim(sessionId);
+                        return NextResponse.json({
+                            claimed: false,
+                            reason: 'Session state expired, work item dropped',
+                        });
+                    }
+                    if (sessionState.status !== 'pending') {
+                        log.warn('Session not in pending status, dropping work item', {
+                            sessionId,
+                            workerId,
+                            issueIdentifier: work.issueIdentifier,
+                            sessionStatus: sessionState.status,
+                        });
+                        await releaseClaim(sessionId);
+                        return NextResponse.json({
+                            claimed: false,
+                            reason: `Session in ${sessionState.status} status, work item dropped`,
+                        });
+                    }
+                    log.warn('Transient failure updating session state, re-queuing', {
+                        sessionId,
+                        workerId,
+                    });
+                    await requeueWork(work);
+                    return NextResponse.json({
+                        claimed: false,
+                        reason: 'Session state update failed, work re-queued',
+                    });
+                }
+                claimSucceeded = true;
+                await addWorkerSession(workerId, sessionId);
+                const session = await getSessionState(sessionId);
+                log.info('Session claimed', {
+                    sessionId,
+                    workerId,
+                    issueIdentifier: work.issueIdentifier,
+                });
+                return NextResponse.json({
+                    claimed: true,
+                    session,
+                    work,
+                });
+            }
+            catch (innerError) {
+                // claimWork succeeded (work removed from queue, claim key set) but
+                // something after it threw. Release claim and requeue the work to
+                // prevent the item from being stuck.
+                log.error('Error after claimWork succeeded, requeuing', {
+                    error: innerError,
+                    sessionId,
+                    workerId,
+                    claimSucceeded,
+                });
+                try {
+                    await requeueWork(work);
+                }
+                catch (requeueError) {
+                    // Last resort: at least release the claim key so the work
+                    // (if it somehow remains in the queue) isn't permanently blocked
+                    log.error('Failed to requeue work after claim error', {
+                        requeueError,
+                        sessionId,
+                    });
+                    try {
+                        await releaseClaim(sessionId);
+                    }
+                    catch { /* best effort */ }
+                }
+                return NextResponse.json({ error: 'Internal Server Error', message: 'Failed to claim session' }, { status: 500 });
+            }
+        }
+        catch (error) {
+            log.error('Failed to claim session', { error, sessionId });
+            return NextResponse.json({ error: 'Internal Server Error', message: 'Failed to claim session' }, { status: 500 });
+        }
+    };
+}

package/dist/src/handlers/sessions/completion.d.ts

@@ -0,0 +1,16 @@
+/**
+ * POST /api/sessions/[id]/completion
+ *
+ * Post agent completion comment to Linear.
+ * Uses multi-comment splitting for long messages.
+ */
+import { NextRequest, NextResponse } from 'next/server';
+import type { RouteConfig } from '../../types.js';
+interface RouteParams {
+    params: Promise<{
+        id: string;
+    }>;
+}
+export declare function createSessionCompletionHandler(config: RouteConfig): (request: NextRequest, { params }: RouteParams) => Promise<NextResponse<unknown>>;
+export {};
+//# sourceMappingURL=completion.d.ts.map

package/dist/src/handlers/sessions/completion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"completion.d.ts","sourceRoot":"","sources":["../../../../src/handlers/sessions/completion.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAIvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAIjD,UAAU,WAAW;IACnB,MAAM,EAAE,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAChC;AAWD,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,WAAW,IACrC,SAAS,WAAW,EAAE,YAAY,WAAW,oCA6FzE"}

package/dist/src/handlers/sessions/completion.js

@@ -0,0 +1,82 @@
+/**
+ * POST /api/sessions/[id]/completion
+ *
+ * Post agent completion comment to Linear.
+ * Uses multi-comment splitting for long messages.
+ */
+import { NextResponse } from 'next/server';
+import { requireWorkerAuth } from '../../middleware/worker-auth.js';
+import { getSessionState, createLogger } from '@renseiai/agentfactory-server';
+import { buildCompletionComments } from '@renseiai/agentfactory-linear';
+const log = createLogger('api:sessions:completion');
+export function createSessionCompletionHandler(config) {
+    return async function POST(request, { params }) {
+        const authError = requireWorkerAuth(request);
+        if (authError)
+            return authError;
+        const { id: sessionId } = await params;
+        try {
+            const body = (await request.json());
+            const { workerId, summary, planItems = [] } = body;
+            if (!summary || typeof summary !== 'string') {
+                return NextResponse.json({ error: 'Bad Request', message: 'summary is required' }, { status: 400 });
+            }
+            const session = await getSessionState(sessionId);
+            if (!session) {
+                return NextResponse.json({ error: 'Not Found', message: 'Session not found' }, { status: 404 });
+            }
+            if (workerId && session.workerId && session.workerId !== workerId) {
+                return NextResponse.json({ error: 'Forbidden', message: 'Session is owned by another worker' }, { status: 403 });
+            }
+            const comments = buildCompletionComments(summary, planItems, sessionId);
+            log.info('Posting completion comments', {
+                sessionId,
+                issueId: session.issueId,
+                parts: comments.length,
+                summaryLength: summary.length,
+            });
+            const linearClient = await config.linearClient.getClient(session.organizationId);
+            let postedCount = 0;
+            const errors = [];
+            for (const chunk of comments) {
+                try {
+                    await linearClient.createComment(session.issueId, chunk.body);
+                    postedCount++;
+                    log.debug(`Posted completion comment part ${chunk.partNumber}/${chunk.totalParts}`, {
+                        sessionId,
+                        issueId: session.issueId,
+                    });
+                    if (chunk.partNumber < chunk.totalParts) {
+                        await new Promise((resolve) => setTimeout(resolve, 100));
+                    }
+                }
+                catch (error) {
+                    const errorMsg = error instanceof Error ? error.message : String(error);
+                    errors.push(`Part ${chunk.partNumber}: ${errorMsg}`);
+                    log.error(`Failed to post completion comment part ${chunk.partNumber}`, {
+                        error,
+                        sessionId,
+                        issueId: session.issueId,
+                    });
+                }
+            }
+            if (postedCount === 0) {
+                return NextResponse.json({
+                    error: 'Internal Server Error',
+                    message: 'Failed to post any completion comments',
+                    errors,
+                }, { status: 500 });
+            }
+            return NextResponse.json({
+                posted: true,
+                partsPosted: postedCount,
+                totalParts: comments.length,
+                errors: errors.length > 0 ? errors : undefined,
+            });
+        }
+        catch (error) {
+            log.error('Failed to process completion', { error, sessionId });
+            return NextResponse.json({ error: 'Internal Server Error', message: 'Failed to process completion' }, { status: 500 });
+        }
+    };
+}

package/dist/src/handlers/sessions/external-urls.d.ts

@@ -0,0 +1,15 @@
+/**
+ * POST /api/sessions/[id]/external-urls
+ *
+ * Update external URLs for an agent session.
+ */
+import { NextRequest, NextResponse } from 'next/server';
+import type { RouteConfig } from '../../types.js';
+interface RouteParams {
+    params: Promise<{
+        id: string;
+    }>;
+}
+export declare function createSessionExternalUrlsHandler(config: RouteConfig): (request: NextRequest, { params }: RouteParams) => Promise<NextResponse<unknown>>;
+export {};
+//# sourceMappingURL=external-urls.d.ts.map

package/dist/src/handlers/sessions/external-urls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"external-urls.d.ts","sourceRoot":"","sources":["../../../../src/handlers/sessions/external-urls.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAGvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAIjD,UAAU,WAAW;IACnB,MAAM,EAAE,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAChC;AAOD,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,WAAW,IACvC,SAAS,WAAW,EAAE,YAAY,WAAW,oCAoFzE"}

package/dist/src/handlers/sessions/external-urls.js

@@ -0,0 +1,70 @@
+/**
+ * POST /api/sessions/[id]/external-urls
+ *
+ * Update external URLs for an agent session.
+ */
+import { NextResponse } from 'next/server';
+import { requireWorkerAuth } from '../../middleware/worker-auth.js';
+import { getSessionState, createLogger } from '@renseiai/agentfactory-server';
+const log = createLogger('api:sessions:external-urls');
+export function createSessionExternalUrlsHandler(config) {
+    return async function POST(request, { params }) {
+        const authError = requireWorkerAuth(request);
+        if (authError)
+            return authError;
+        const { id: sessionId } = await params;
+        try {
+            const body = await request.json();
+            const { externalUrls, workspaceId } = body;
+            if (!externalUrls || !Array.isArray(externalUrls)) {
+                return NextResponse.json({ error: 'Bad Request', message: 'externalUrls array is required' }, { status: 400 });
+            }
+            for (const extUrl of externalUrls) {
+                if (!extUrl.label || !extUrl.url) {
+                    return NextResponse.json({ error: 'Bad Request', message: 'Each external URL must have label and url' }, { status: 400 });
+                }
+            }
+            const session = await getSessionState(sessionId);
+            if (!session) {
+                return NextResponse.json({ error: 'Not Found', message: 'Session not found' }, { status: 404 });
+            }
+            // Skip Linear forwarding for governor-generated fake session IDs.
+            if (sessionId.startsWith('governor-')) {
+                log.debug('Skipping Linear external URLs update for governor-generated session', {
+                    sessionId,
+                });
+                return NextResponse.json({
+                    updated: false,
+                    reason: 'Governor-generated session — no Linear agent session exists',
+                });
+            }
+            const effectiveWorkspaceId = workspaceId || session.organizationId;
+            if (!effectiveWorkspaceId) {
+                log.warn('No workspace ID available, falling back to default client', {
+                    sessionId,
+                    hasWorkspaceIdInRequest: !!workspaceId,
+                    hasOrganizationIdInSession: !!session.organizationId,
+                });
+            }
+            const linearClient = await config.linearClient.getClient(effectiveWorkspaceId);
+            await linearClient.updateAgentSession({
+                sessionId,
+                externalUrls,
+            });
+            log.info('External URLs updated', {
+                sessionId,
+                urlCount: externalUrls.length,
+                labels: externalUrls.map((u) => u.label),
+            });
+            return NextResponse.json({
+                updated: true,
+                externalUrls,
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            log.error('Failed to update external URLs', { error: errorMessage, sessionId });
+            return NextResponse.json({ error: 'Internal Server Error', message: `Failed to update external URLs: ${errorMessage}` }, { status: 500 });
+        }
+    };
+}

package/dist/src/handlers/sessions/get.d.ts

@@ -0,0 +1,19 @@
+/**
+ * GET /api/sessions/[id]
+ * Returns a single agent session by ID
+ */
+import { NextRequest, NextResponse } from 'next/server';
+import type { AgentSessionResponse } from './list.js';
+interface RouteParams {
+    params: Promise<{
+        id: string;
+    }>;
+}
+export declare function createSessionGetHandler(): (_request: NextRequest, { params }: RouteParams) => Promise<NextResponse<{
+    error: string;
+    message: string;
+}> | NextResponse<{
+    session: AgentSessionResponse;
+}>>;
+export {};
+//# sourceMappingURL=get.d.ts.map

package/dist/src/handlers/sessions/get.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get.d.ts","sourceRoot":"","sources":["../../../../src/handlers/sessions/get.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAEvD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAA;AAIrD,UAAU,WAAW;IACnB,MAAM,EAAE,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAChC;AAyBD,wBAAgB,uBAAuB,KACX,UAAU,WAAW,EAAE,YAAY,WAAW;;;;;IAwBzE"}

package/dist/src/handlers/sessions/get.js

@@ -0,0 +1,47 @@
+/**
+ * GET /api/sessions/[id]
+ * Returns a single agent session by ID
+ */
+import { NextResponse } from 'next/server';
+import { getSessionState, createLogger } from '@renseiai/agentfactory-server';
+const log = createLogger('api:sessions:[id]');
+function toResponse(session) {
+    return {
+        id: session.linearSessionId,
+        linearSessionId: session.linearSessionId,
+        issueId: session.issueId,
+        identifier: session.issueIdentifier || session.issueId.slice(0, 8),
+        providerSessionId: session.providerSessionId || undefined,
+        provider: session.provider || undefined,
+        status: session.status,
+        createdAt: new Date(session.createdAt * 1000).toISOString(),
+        updatedAt: new Date(session.updatedAt * 1000).toISOString(),
+        worktreePath: session.worktreePath,
+        workerId: session.workerId || undefined,
+        queuedAt: session.queuedAt
+            ? new Date(session.queuedAt).toISOString()
+            : undefined,
+        claimedAt: session.claimedAt
+            ? new Date(session.claimedAt * 1000).toISOString()
+            : undefined,
+        agentId: session.agentId || undefined,
+    };
+}
+export function createSessionGetHandler() {
+    return async function GET(_request, { params }) {
+        const { id: sessionId } = await params;
+        try {
+            const session = await getSessionState(sessionId);
+            if (!session) {
+                return NextResponse.json({ error: 'Not Found', message: 'Session not found' }, { status: 404 });
+            }
+            return NextResponse.json({
+                session: toResponse(session),
+            });
+        }
+        catch (error) {
+            log.error('Failed to fetch session', { error, sessionId });
+            return NextResponse.json({ error: 'Internal Server Error', message: 'Failed to fetch session' }, { status: 500 });
+        }
+    };
+}

package/dist/src/handlers/sessions/list.d.ts

@@ -0,0 +1,27 @@
+/**
+ * GET /api/sessions
+ * Returns list of all agent sessions from Redis
+ */
+import { NextResponse } from 'next/server';
+export interface AgentSessionResponse {
+    id: string;
+    linearSessionId: string;
+    issueId: string;
+    identifier: string;
+    providerSessionId?: string;
+    provider?: string;
+    status: 'pending' | 'claimed' | 'running' | 'finalizing' | 'completed' | 'failed' | 'stopped';
+    createdAt: string;
+    updatedAt: string;
+    worktreePath: string;
+    workerId?: string;
+    queuedAt?: string;
+    claimedAt?: string;
+    agentId?: string;
+}
+export declare function createSessionListHandler(): () => Promise<NextResponse<{
+    sessions: AgentSessionResponse[];
+    count: number;
+    timestamp: string;
+}>>;
+//# sourceMappingURL=list.d.ts.map

package/dist/src/handlers/sessions/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../../src/handlers/sessions/list.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAK1C,MAAM,WAAW,oBAAoB;IACnC,EAAE,EAAE,MAAM,CAAA;IACV,eAAe,EAAE,MAAM,CAAA;IACvB,OAAO,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,MAAM,CAAA;IAClB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,YAAY,GAAG,WAAW,GAAG,QAAQ,GAAG,SAAS,CAAA;IAC7F,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,YAAY,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAyBD,wBAAgB,wBAAwB;;;;IAsBvC"}

package/dist/src/handlers/sessions/list.js

@@ -0,0 +1,51 @@
+/**
+ * GET /api/sessions
+ * Returns list of all agent sessions from Redis
+ */
+import { NextResponse } from 'next/server';
+import { getAllSessions, createLogger } from '@renseiai/agentfactory-server';
+const log = createLogger('api/sessions');
+function toResponse(session) {
+    return {
+        id: session.linearSessionId,
+        linearSessionId: session.linearSessionId,
+        issueId: session.issueId,
+        identifier: session.issueIdentifier || session.issueId.slice(0, 8),
+        providerSessionId: session.providerSessionId || undefined,
+        provider: session.provider || undefined,
+        status: session.status,
+        createdAt: new Date(session.createdAt * 1000).toISOString(),
+        updatedAt: new Date(session.updatedAt * 1000).toISOString(),
+        worktreePath: session.worktreePath,
+        workerId: session.workerId || undefined,
+        queuedAt: session.queuedAt
+            ? new Date(session.queuedAt).toISOString()
+            : undefined,
+        claimedAt: session.claimedAt
+            ? new Date(session.claimedAt * 1000).toISOString()
+            : undefined,
+        agentId: session.agentId || undefined,
+    };
+}
+export function createSessionListHandler() {
+    return async function GET() {
+        try {
+            const allSessions = await getAllSessions();
+            const sessions = allSessions.map(toResponse);
+            return NextResponse.json({
+                sessions,
+                count: sessions.length,
+                timestamp: new Date().toISOString(),
+            });
+        }
+        catch (error) {
+            log.error('Failed to fetch sessions', { error });
+            return NextResponse.json({
+                sessions: [],
+                count: 0,
+                timestamp: new Date().toISOString(),
+                error: 'Failed to fetch sessions from Redis',
+            });
+        }
+    };
+}

package/dist/src/handlers/sessions/lock-refresh.d.ts

@@ -0,0 +1,14 @@
+/**
+ * POST /api/sessions/[id]/lock-refresh
+ *
+ * Refresh the issue lock TTL for an active session.
+ */
+import { NextRequest, NextResponse } from 'next/server';
+interface RouteParams {
+    params: Promise<{
+        id: string;
+    }>;
+}
+export declare function createSessionLockRefreshHandler(): (request: NextRequest, { params }: RouteParams) => Promise<NextResponse<unknown>>;
+export {};
+//# sourceMappingURL=lock-refresh.d.ts.map

package/dist/src/handlers/sessions/lock-refresh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock-refresh.d.ts","sourceRoot":"","sources":["../../../../src/handlers/sessions/lock-refresh.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAMvD,UAAU,WAAW;IACnB,MAAM,EAAE,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAChC;AAED,wBAAgB,+BAA+B,KAClB,SAAS,WAAW,EAAE,YAAY,WAAW,oCA6CzE"}

package/dist/src/handlers/sessions/lock-refresh.js

@@ -0,0 +1,38 @@
+/**
+ * POST /api/sessions/[id]/lock-refresh
+ *
+ * Refresh the issue lock TTL for an active session.
+ */
+import { NextResponse } from 'next/server';
+import { requireWorkerAuth } from '../../middleware/worker-auth.js';
+import { getSessionState, refreshIssueLockTTL, createLogger } from '@renseiai/agentfactory-server';
+const log = createLogger('api:sessions:lock-refresh');
+export function createSessionLockRefreshHandler() {
+    return async function POST(request, { params }) {
+        const authError = requireWorkerAuth(request);
+        if (authError)
+            return authError;
+        const { id: sessionId } = await params;
+        try {
+            const body = await request.json();
+            const { workerId, issueId } = body;
+            if (!workerId || !issueId) {
+                return NextResponse.json({ error: 'Bad Request', message: 'workerId and issueId are required' }, { status: 400 });
+            }
+            const session = await getSessionState(sessionId);
+            if (!session) {
+                return NextResponse.json({ error: 'Not Found', message: 'Session not found' }, { status: 404 });
+            }
+            if (session.workerId && session.workerId !== workerId) {
+                return NextResponse.json({ error: 'Forbidden', message: 'Session is owned by another worker' }, { status: 403 });
+            }
+            const refreshed = await refreshIssueLockTTL(issueId);
+            log.debug('Lock TTL refreshed', { sessionId, issueId, refreshed });
+            return NextResponse.json({ refreshed });
+        }
+        catch (error) {
+            log.error('Failed to refresh lock TTL', { error, sessionId });
+            return NextResponse.json({ error: 'Internal Server Error', message: 'Failed to refresh lock TTL' }, { status: 500 });
+        }
+    };
+}

package/dist/src/handlers/sessions/progress.d.ts

@@ -0,0 +1,15 @@
+/**
+ * POST /api/sessions/[id]/progress
+ *
+ * Post a progress update as an agent activity to Linear.
+ */
+import { NextRequest, NextResponse } from 'next/server';
+import type { RouteConfig } from '../../types.js';
+interface RouteParams {
+    params: Promise<{
+        id: string;
+    }>;
+}
+export declare function createSessionProgressHandler(config: RouteConfig): (request: NextRequest, { params }: RouteParams) => Promise<NextResponse<unknown>>;
+export {};
+//# sourceMappingURL=progress.d.ts.map

package/dist/src/handlers/sessions/progress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress.d.ts","sourceRoot":"","sources":["../../../../src/handlers/sessions/progress.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAGvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAIjD,UAAU,WAAW;IACnB,MAAM,EAAE,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAChC;AAeD,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,WAAW,IACnC,SAAS,WAAW,EAAE,YAAY,WAAW,oCAmGzE"}

package/dist/src/handlers/sessions/progress.js

@@ -0,0 +1,94 @@
+/**
+ * POST /api/sessions/[id]/progress
+ *
+ * Post a progress update as an agent activity to Linear.
+ */
+import { NextResponse } from 'next/server';
+import { requireWorkerAuth } from '../../middleware/worker-auth.js';
+import { getSessionState, createLogger } from '@renseiai/agentfactory-server';
+const log = createLogger('api:sessions:progress');
+const MILESTONE_EMOJI = {
+    claimed: '\u{1f527}',
+    worktree: '\u{1f4c2}',
+    started: '\u{1f916}',
+    running: '\u23f3',
+    tests: '\u{1f9ea}',
+    pr: '\u{1f500}',
+    completed: '\u2705',
+    failed: '\u274c',
+    stopped: '\u{1f6d1}',
+    resumed: '\u{1f504}',
+};
+export function createSessionProgressHandler(config) {
+    return async function POST(request, { params }) {
+        const authError = requireWorkerAuth(request);
+        if (authError)
+            return authError;
+        const { id: sessionId } = await params;
+        try {
+            const body = await request.json();
+            const { workerId, milestone, message } = body;
+            if (!workerId || typeof workerId !== 'string') {
+                return NextResponse.json({ error: 'Bad Request', message: 'workerId is required' }, { status: 400 });
+            }
+            if (!message || typeof message !== 'string') {
+                return NextResponse.json({ error: 'Bad Request', message: 'message is required' }, { status: 400 });
+            }
+            const session = await getSessionState(sessionId);
+            if (!session) {
+                return NextResponse.json({ error: 'Not Found', message: 'Session not found' }, { status: 404 });
+            }
+            if (session.workerId && session.workerId !== workerId) {
+                return NextResponse.json({ error: 'Forbidden', message: 'Session is owned by another worker' }, { status: 403 });
+            }
+            // Skip Linear forwarding for governor-generated fake session IDs.
+            if (sessionId.startsWith('governor-')) {
+                log.debug('Skipping Linear progress post for governor-generated session', {
+                    sessionId,
+                    milestone,
+                });
+                return NextResponse.json({
+                    posted: false,
+                    reason: 'Governor-generated session — no Linear agent session exists',
+                });
+            }
+            const emoji = milestone ? MILESTONE_EMOJI[milestone] || '\u2139\ufe0f' : '';
+            const formattedMessage = emoji ? `${emoji} ${message}` : message;
+            try {
+                const linearClient = await config.linearClient.getClient(session.organizationId);
+                await linearClient.createAgentActivity({
+                    agentSessionId: session.linearSessionId,
+                    content: { type: 'response', body: formattedMessage },
+                    ephemeral: false,
+                });
+                log.info('Progress activity posted', {
+                    sessionId,
+                    linearSessionId: session.linearSessionId,
+                    milestone,
+                    messageLength: message.length,
+                });
+                return NextResponse.json({
+                    posted: true,
+                    milestone,
+                });
+            }
+            catch (linearError) {
+                const errorMessage = linearError instanceof Error ? linearError.message : String(linearError);
+                log.error('Failed to post progress activity to Linear', {
+                    error: errorMessage,
+                    sessionId,
+                    linearSessionId: session.linearSessionId,
+                    milestone,
+                });
+                return NextResponse.json({
+                    posted: false,
+                    reason: `Failed to post to Linear: ${errorMessage}`,
+                });
+            }
+        }
+        catch (error) {
+            log.error('Failed to process progress update', { error, sessionId });
+            return NextResponse.json({ error: 'Internal Server Error', message: 'Failed to process progress update' }, { status: 500 });
+        }
+    };
+}