@todoist/doistbot-cli 0.0.0-stage → 1.0.16

package/sandbox/dist/tasks/issue-summarize/model.js

@@ -0,0 +1,230 @@
+import { SpanStatusCode } from '@opentelemetry/api';
+import { logger } from '../../core/logging.js';
+import { buildPiImageContent, createPiInvoker, DEFAULT_GEMINI_FLASH_MODEL, DEFAULT_OPENROUTER_MODELS, } from '../../core/pi.js';
+import { withPhase } from '../../core/tracing.js';
+const ISSUE_SUMMARIZE_TIMEOUT_MS = 5 * 60 * 1000;
+const ISSUE_SUMMARIZE_MULTIMODAL_MODEL = DEFAULT_GEMINI_FLASH_MODEL;
+const SUMMARIZE_TEXT_PROVIDER = 'zai';
+// Single source of truth: inherit the repo-wide Z.ai default so a default-model
+// bump in core/pi.ts moves summarize too, and the executed model matches the
+// recorded gen_ai.request.model.
+const SUMMARIZE_TEXT_MODEL = DEFAULT_OPENROUTER_MODELS.zai;
+const SUMMARIZE_MULTIMODAL_PROVIDER = 'gcp.gemini';
+// One model span per actual model.invoke. The final summary uses
+// `issue-summarize.model`; each chunk summary uses `issue-summarize.chunk`.
+const SUMMARIZE_MODEL_PHASE = 'issue-summarize.model';
+const SUMMARIZE_CHUNK_PHASE = 'issue-summarize.chunk';
+export function createIssueSummarizeTextModel(apiKey) {
+    return createPiInvoker({
+        provider: 'zai',
+        apiKey,
+        piProviderId: 'openrouter',
+        cwd: process.cwd(),
+        capabilityPreset: 'read-only',
+    });
+}
+export function createIssueSummarizeMultimodalModel(apiKey) {
+    return createPiInvoker({
+        provider: 'gemini',
+        apiKey,
+        piProviderId: 'google',
+        cwd: process.cwd(),
+        capabilityPreset: 'read-only',
+    });
+}
+async function invokeIssueSummarizeTextModel({ model, prompt, phaseName, }) {
+    return withPhase(phaseName, {
+        'gen_ai.operation.name': 'chat',
+        'gen_ai.provider.name': SUMMARIZE_TEXT_PROVIDER,
+        'gen_ai.request.model': SUMMARIZE_TEXT_MODEL,
+    }, async (span) => {
+        const result = await model.invoke({
+            prompt,
+            modelName: SUMMARIZE_TEXT_MODEL,
+            timeoutMs: ISSUE_SUMMARIZE_TIMEOUT_MS,
+        });
+        if (!result.ok) {
+            span.setStatus({ code: SpanStatusCode.ERROR, message: result.error });
+            logger.warn('Issue summarize model request failed', {
+                error: result.error,
+                timedOut: result.timedOut,
+            });
+            return null;
+        }
+        const output = result.output.trim() || null;
+        if (!output) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: 'summarize model produced no output',
+            });
+        }
+        return output;
+    });
+}
+// One model span for the multimodal model.invoke (provider/model known at
+// start). On failure it returns null and the caller falls back to a separate
+// text request — which emits its own model span, so a fallback shows two real
+// model calls rather than one.
+async function invokeMultimodalSummarizeModel({ model, prompt, mediaImages, }) {
+    const mediaContext = mediaImages
+        .map((mediaImage, index) => [
+        `Media item ${index + 1} of ${mediaImages.length}`,
+        `URL: ${mediaImage.url}`,
+        `Source: ${mediaImage.sourceLabel}`,
+        `Author: ${mediaImage.author}`,
+        '',
+        mediaImage.sourceContext,
+    ].join('\n'))
+        .join('\n\n');
+    return withPhase(SUMMARIZE_MODEL_PHASE, {
+        'gen_ai.operation.name': 'chat',
+        'gen_ai.provider.name': SUMMARIZE_MULTIMODAL_PROVIDER,
+        'gen_ai.request.model': ISSUE_SUMMARIZE_MULTIMODAL_MODEL,
+    }, async (span) => {
+        try {
+            const result = await model.invoke({
+                modelName: ISSUE_SUMMARIZE_MULTIMODAL_MODEL,
+                prompt: `${prompt}\n\n<media_context>\n${mediaContext}\n</media_context>`,
+                timeoutMs: ISSUE_SUMMARIZE_TIMEOUT_MS,
+                images: mediaImages.map((mediaImage) => buildPiImageContent({
+                    dataBase64: mediaImage.dataBase64,
+                    contentType: mediaImage.contentType,
+                })),
+            });
+            if (!result.ok) {
+                span.setStatus({ code: SpanStatusCode.ERROR, message: result.error });
+                logger.warn('Issue summarize multimodal request failed', {
+                    error: result.error,
+                    timedOut: result.timedOut,
+                    mediaImages: mediaImages.length,
+                });
+                return null;
+            }
+            const text = result.output.trim();
+            if (!text) {
+                span.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: 'multimodal summarize produced no output',
+                });
+                logger.warn('Issue summarize multimodal request returned empty output', {
+                    mediaImages: mediaImages.length,
+                });
+                return null;
+            }
+            return text;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            span.setStatus({ code: SpanStatusCode.ERROR, message });
+            logger.warn('Issue summarize multimodal request errored', {
+                error: message,
+                mediaImages: mediaImages.length,
+            });
+            return null;
+        }
+    });
+}
+export async function invokeIssueSummarizeModel({ textModel, multimodalModel, prompt, mediaImages, }) {
+    if (mediaImages.length === 0) {
+        logger.info('Using text-only summarize model request');
+        return await invokeIssueSummarizeTextModel({
+            model: textModel,
+            prompt,
+            phaseName: SUMMARIZE_MODEL_PHASE,
+        });
+    }
+    logger.info('Using multimodal summarize model request', {
+        mediaImages: mediaImages.length,
+    });
+    const multimodal = await invokeMultimodalSummarizeModel({
+        model: multimodalModel,
+        prompt,
+        mediaImages,
+    });
+    if (multimodal) {
+        return multimodal;
+    }
+    // Multimodal failed — fall back to a separate text request (own model span).
+    return await invokeIssueSummarizeTextModel({
+        model: textModel,
+        prompt,
+        phaseName: SUMMARIZE_MODEL_PHASE,
+    });
+}
+function buildChunkSummaryPrompt({ chunk, chunkIndex, selectedChunkCount, totalChunks, }) {
+    return `You are preparing an intermediate summary for a GitHub issue discussion.
+
+Chunk ${chunkIndex + 1} of ${selectedChunkCount} selected chunks (from ${totalChunks} total chunks).
+
+Summarize this chunk in markdown with these headings:
+
+## Key updates
+## Decisions
+## Open questions
+## Action items
+
+Be concise and factual. If a section has no data, use "- None noted in this chunk."
+
+<chunk_content>
+${chunk}
+</chunk_content>`;
+}
+export async function summarizeChunks({ model, chunks, totalChunks, }) {
+    // Workflow phase: it orchestrates one model request PER chunk, so it is not
+    // itself a single gen-AI operation and carries no gen_ai.* attrs.
+    return withPhase('issue-summarize.chunks', {
+        'chunks.selected': chunks.length,
+        'chunks.total': totalChunks,
+    }, async (span) => summarizeChunksInner({ model, chunks, totalChunks }, span));
+}
+async function summarizeChunksInner({ model, chunks, totalChunks, }, span) {
+    const summaries = [];
+    let missingChunkSummaries = 0;
+    logger.info('Summarizing issue thread in chunks', {
+        selectedChunks: chunks.length,
+        totalChunks,
+    });
+    for (const [index, chunk] of chunks.entries()) {
+        const chunkPrompt = buildChunkSummaryPrompt({
+            chunk,
+            chunkIndex: index,
+            selectedChunkCount: chunks.length,
+            totalChunks,
+        });
+        const chunkSummary = await invokeIssueSummarizeTextModel({
+            model,
+            prompt: chunkPrompt,
+            phaseName: SUMMARIZE_CHUNK_PHASE,
+        });
+        if (chunkSummary?.trim()) {
+            summaries.push(`### Chunk ${index + 1}\n${chunkSummary.trim()}`);
+        }
+        else {
+            missingChunkSummaries += 1;
+        }
+    }
+    span.setAttributes({ 'chunks.summarized': summaries.length });
+    if (summaries.length === 0) {
+        // No chunk produced a model summary — we fall back to raw chunk content.
+        span.setStatus({
+            code: SpanStatusCode.ERROR,
+            message: 'chunk summarization produced no model output',
+        });
+        logger.warn('Chunk summarization returned no model output, using raw chunk content', {
+            selectedChunks: chunks.length,
+            totalChunks,
+        });
+        return chunks.map((chunk, index) => `### Chunk ${index + 1}\n${chunk}`).join('\n\n---\n\n');
+    }
+    if (missingChunkSummaries > 0) {
+        logger.warn('Some chunk summaries returned empty output', {
+            missingChunkSummaries,
+            selectedChunks: chunks.length,
+        });
+    }
+    logger.info('Chunk summarization completed', {
+        selectedChunks: chunks.length,
+        chunkSummaries: summaries.length,
+    });
+    return summaries.join('\n\n---\n\n');
+}

package/sandbox/dist/tasks/issue-summarize/output.js

@@ -0,0 +1,45 @@
+export function buildFallbackSummary({ issue, entryCount, coverageNote, }) {
+    return [
+        '## Current state',
+        `Issue #${issue.number} (“${issue.title ?? 'Untitled issue'}”) was analyzed across ${entryCount} thread entries.`,
+        `${coverageNote}`,
+        '',
+        '## Key decisions',
+        '- No reliable decision extraction was available from the model output. Review the issue thread directly for decision details.',
+        '',
+        '## Open questions',
+        '- Open questions could not be extracted confidently from the model output.',
+        '',
+        '## Next action steps',
+        '- Re-run `/summarize` or review recent issue comments manually for a precise status update.',
+    ].join('\n');
+}
+export function stripVisualContextSection(summary) {
+    const withoutVisualContext = summary.replace(/\n*##\s*Visual context\b[\s\S]*?(?=\n##\s|$)/gi, '\n');
+    return withoutVisualContext.trim();
+}
+export function ensureStructuredSummary(summary) {
+    const requiredHeadings = [
+        '## Current state',
+        '## Key decisions',
+        '## Open questions',
+        '## Next action steps',
+    ];
+    const hasAllHeadings = requiredHeadings.every((heading) => summary.includes(heading));
+    if (hasAllHeadings) {
+        return summary.trim();
+    }
+    return [
+        '## Current state',
+        summary.trim(),
+        '',
+        '## Key decisions',
+        '- Not explicitly identified.',
+        '',
+        '## Open questions',
+        '- Not explicitly identified.',
+        '',
+        '## Next action steps',
+        '- Review the issue thread for concrete next actions.',
+    ].join('\n');
+}

package/sandbox/dist/tasks/issue-summarize/prompt.js

@@ -0,0 +1,11 @@
+import { fillPromptTemplate, loadPromptTemplateFile, resolvePromptFile, } from '../../core/prompt-template.js';
+const PROMPT_FILE = 'issue-summarize-prompt.md';
+export function loadPromptTemplate() {
+    return loadPromptTemplateFile({
+        fileName: resolvePromptFile(import.meta.url, PROMPT_FILE),
+        promptLabel: 'issue summarize',
+    });
+}
+export function fillTemplate(template, variables) {
+    return fillPromptTemplate(template, variables);
+}

package/sandbox/dist/tasks/issue-summarize/summarize.js

@@ -0,0 +1,238 @@
+import { SpanStatusCode } from '@opentelemetry/api';
+import { App } from 'octokit';
+import { fetchIssue, fetchIssueComments } from '../../core/github-issues.js';
+import { logger } from '../../core/logging.js';
+import { removeIssueCommentReactionIfPresent } from '../../core/reactions.js';
+import { resolveWriteOctokit } from '../../core/shared.js';
+import { withPhase } from '../../core/tracing.js';
+import { shutdownTracing } from '../../core/tracing-setup.js';
+import { parseSummarizeContext } from './context.js';
+import { buildMediaPromptImages, extractMediaReferences, formatMediaContext, inspectMediaReferences, } from './media.js';
+import { createIssueSummarizeMultimodalModel, createIssueSummarizeTextModel, invokeIssueSummarizeModel, summarizeChunks, } from './model.js';
+import { buildFallbackSummary, ensureStructuredSummary, stripVisualContextSection, } from './output.js';
+import { fillTemplate, loadPromptTemplate } from './prompt.js';
+import { buildThreadEntries, prepareThreadPrompt } from './thread.js';
+const SUMMARY_MARKER = '<!--doistbot-issue-summary-->';
+export { parseSummarizeContext } from './context.js';
+export { extractMediaReferences, inspectMediaReferences } from './media.js';
+export { buildThreadEntries, prepareThreadPrompt } from './thread.js';
+function summarizeMediaInspectionStats(mediaInspections) {
+    const stats = {
+        fetched: 0,
+        fetchFailed: 0,
+        notMedia: 0,
+    };
+    for (const inspection of mediaInspections) {
+        switch (inspection.status) {
+            case 'fetched':
+                stats.fetched += 1;
+                break;
+            case 'fetch_failed':
+                stats.fetchFailed += 1;
+                break;
+            case 'not_media':
+                stats.notMedia += 1;
+                break;
+            default:
+                break;
+        }
+    }
+    return stats;
+}
+async function summarizeIssue({ ctx, issue, entries, mediaReferences, mediaInspections, }) {
+    const template = loadPromptTemplate();
+    const threadPrompt = prepareThreadPrompt(entries);
+    const textModel = createIssueSummarizeTextModel(ctx.openRouterApiKey);
+    const multimodalModel = createIssueSummarizeMultimodalModel(ctx.geminiApiKey);
+    logger.info('Prepared summarize thread prompt', {
+        entryCount: entries.length,
+        chunked: threadPrompt.chunked,
+        selectedChunks: threadPrompt.chunks.length,
+        totalChunks: threadPrompt.totalChunks,
+    });
+    const threadContent = threadPrompt.chunked
+        ? await summarizeChunks({
+            model: textModel,
+            chunks: threadPrompt.chunks,
+            totalChunks: threadPrompt.totalChunks,
+        })
+        : (threadPrompt.chunks[0] ?? '');
+    const prompt = fillTemplate(template, {
+        REPO_FULL: `${ctx.owner}/${ctx.repo}`,
+        ISSUE_NUMBER: String(ctx.issueNumber),
+        ISSUE_TITLE: issue.title ?? '(No title)',
+        ISSUE_AUTHOR: issue.user?.login ?? 'unknown',
+        ISSUE_STATE: issue.state ?? 'unknown',
+        ISSUE_URL: issue.html_url ??
+            `https://github.com/${ctx.owner}/${ctx.repo}/issues/${ctx.issueNumber}`,
+        ISSUE_BODY: issue.body?.trim() || '(No issue description provided.)',
+        THREAD_COVERAGE: threadPrompt.coverageNote,
+        THREAD_CONTENT: threadContent,
+        MEDIA_CONTEXT: formatMediaContext(mediaInspections),
+    });
+    const mediaPromptImages = await buildMediaPromptImages(mediaReferences, mediaInspections);
+    logger.info('Prepared summarize media payload', {
+        mediaReferences: mediaReferences.length,
+        mediaInspections: mediaInspections.length,
+        mediaImagesIncluded: mediaPromptImages.length,
+    });
+    const summary = await invokeIssueSummarizeModel({
+        textModel,
+        multimodalModel,
+        prompt,
+        mediaImages: mediaPromptImages,
+    });
+    if (!summary?.trim()) {
+        logger.warn('Issue summarize model returned empty output, using fallback summary', {
+            issueNumber: ctx.issueNumber,
+            entryCount: entries.length,
+        });
+        return buildFallbackSummary({
+            issue,
+            entryCount: entries.length,
+            coverageNote: threadPrompt.coverageNote,
+        });
+    }
+    return ensureStructuredSummary(stripVisualContextSection(summary));
+}
+async function createGitHubClients(ctx) {
+    const app = new App({
+        appId: ctx.appId,
+        privateKey: ctx.privateKey,
+    });
+    const readOctokit = await app.getInstallationOctokit(ctx.installationId);
+    const writeOctokit = resolveWriteOctokit({
+        githubToken: ctx.githubToken,
+        fallbackOctokit: readOctokit,
+    });
+    return { readOctokit, writeOctokit };
+}
+async function main() {
+    const ctx = parseSummarizeContext();
+    logger.setBaseContext({
+        deliveryId: ctx.deliveryId ?? 'unknown',
+        repository: `${ctx.owner}/${ctx.repo}`,
+        issueNumber: ctx.issueNumber,
+    });
+    let exitCode = 0;
+    await withPhase('issue-summarize', {
+        task: 'issue-summarize',
+        'gen_ai.operation.name': 'invoke_agent',
+        'gen_ai.agent.name': 'doistbot.issue-summarize',
+        'issue.number': ctx.issueNumber,
+        'comment.id': ctx.commentId,
+        dry_run: ctx.dryRun,
+    }, async (span) => {
+        // Inside the span so auth/setup failures are captured by the root span.
+        const { readOctokit, writeOctokit } = await createGitHubClients(ctx);
+        try {
+            const issueParams = {
+                owner: ctx.owner,
+                repo: ctx.repo,
+                issueNumber: ctx.issueNumber,
+                mediaType: { format: 'full' },
+            };
+            const [issue, comments] = await Promise.all([
+                fetchIssue(readOctokit, issueParams),
+                fetchIssueComments(readOctokit, issueParams),
+            ]);
+            logger.info('Loaded issue summarize context', {
+                issueState: issue.state ?? 'unknown',
+                commentsCount: comments.length,
+            });
+            const entries = buildThreadEntries({
+                issue,
+                comments,
+                triggerCommentId: ctx.commentId,
+            });
+            logger.info('Prepared issue summarize thread entries', {
+                issueNumber: issue.number,
+                entryCount: entries.length,
+            });
+            const mediaReferences = extractMediaReferences(entries);
+            const mediaInspections = await inspectMediaReferences(mediaReferences);
+            const mediaInspectionStats = summarizeMediaInspectionStats(mediaInspections);
+            logger.info('Inspected issue summarize media references', {
+                mediaReferences: mediaReferences.length,
+                mediaInspections: mediaInspections.length,
+                mediaFetched: mediaInspectionStats.fetched,
+                mediaFetchFailed: mediaInspectionStats.fetchFailed,
+                mediaNotImage: mediaInspectionStats.notMedia,
+            });
+            const summary = await summarizeIssue({
+                ctx,
+                issue,
+                entries,
+                mediaReferences,
+                mediaInspections,
+            });
+            logger.info('Generated issue summary', {
+                issueNumber: ctx.issueNumber,
+                summaryChars: summary.length,
+            });
+            const summaryComment = `${SUMMARY_MARKER}\n\n${summary}`;
+            if (ctx.dryRun) {
+                logger.info('Dry run enabled, printing summarize output instead of posting comment', { issueNumber: ctx.issueNumber });
+                process.stdout.write(`${summaryComment}\n`);
+            }
+            else {
+                await writeOctokit.rest.issues.createComment({
+                    owner: ctx.owner,
+                    repo: ctx.repo,
+                    issue_number: ctx.issueNumber,
+                    body: summaryComment,
+                });
+                logger.info('Posted issue summary comment', {
+                    issueNumber: ctx.issueNumber,
+                    mediaReferences: mediaReferences.length,
+                });
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error('Issue summarize task failed', {
+                issueNumber: ctx.issueNumber,
+                error: message,
+            });
+            // Set the span status before the run exits; deferring process.exit
+            // until after withPhase lets phase.end flush.
+            span.setStatus({ code: SpanStatusCode.ERROR, message });
+            if (!ctx.dryRun) {
+                try {
+                    await writeOctokit.rest.issues.createComment({
+                        owner: ctx.owner,
+                        repo: ctx.repo,
+                        issue_number: ctx.issueNumber,
+                        body: 'Sorry, I encountered an error while summarizing this issue. Please try again or contact the team maintaining the bot.',
+                    });
+                }
+                catch (replyError) {
+                    logger.warn('Failed to post summarize error response', {
+                        issueNumber: ctx.issueNumber,
+                        error: replyError instanceof Error
+                            ? replyError.message
+                            : String(replyError),
+                    });
+                }
+            }
+            exitCode = 1;
+        }
+        finally {
+            await removeIssueCommentReactionIfPresent({
+                octokit: writeOctokit,
+                owner: ctx.owner,
+                repo: ctx.repo,
+                commentId: ctx.commentId,
+                reactionId: ctx.reactionId,
+                warnMessage: 'Failed to remove summarize reaction',
+            });
+        }
+    });
+    if (exitCode !== 0) {
+        await shutdownTracing();
+        process.exit(exitCode);
+    }
+}
+if (process.env.VITEST !== 'true') {
+    main();
+}

package/sandbox/dist/tasks/issue-summarize/thread.js

@@ -0,0 +1,123 @@
+import { isKnownDoistbotLogin } from '../../core/bot-logins.js';
+const SUMMARY_MARKER = '<!--doistbot-issue-summary-->';
+const SUMMARIZE_COMMAND_REGEX = /^@doistbot \/summarize$/i;
+const MAX_SINGLE_PASS_CHARS = 50_000;
+const CHUNK_TARGET_CHARS = 15_000;
+const MAX_CHUNKS = 6;
+const MAX_ENTRY_BODY_CHARS = 4_000;
+function isBotLogin(login) {
+    if (!login) {
+        return false;
+    }
+    const normalized = login.toLowerCase();
+    return isKnownDoistbotLogin(normalized) || normalized.endsWith('[bot]');
+}
+export function buildThreadEntries({ issue, comments, triggerCommentId, }) {
+    const entries = [];
+    const issueBody = issue.body?.trim() || '(No issue description provided.)';
+    entries.push({
+        source: 'issue_body',
+        id: issue.number,
+        author: issue.user?.login ?? 'unknown',
+        createdAt: issue.created_at ?? 'unknown',
+        url: issue.html_url ?? '',
+        body: issueBody,
+        bodyHtml: issue.body_html ?? undefined,
+    });
+    for (const comment of comments) {
+        const body = comment.body ?? '';
+        const trimmedBody = body.trim();
+        if (!trimmedBody) {
+            continue;
+        }
+        if (triggerCommentId != null && comment.id === triggerCommentId) {
+            continue;
+        }
+        if (trimmedBody.includes(SUMMARY_MARKER)) {
+            continue;
+        }
+        if (SUMMARIZE_COMMAND_REGEX.test(trimmedBody)) {
+            continue;
+        }
+        if (isBotLogin(comment.user?.login)) {
+            continue;
+        }
+        entries.push({
+            source: 'comment',
+            id: comment.id,
+            author: comment.user?.login ?? 'unknown',
+            createdAt: comment.created_at ?? 'unknown',
+            url: comment.html_url ?? '',
+            body: trimmedBody,
+            bodyHtml: comment.body_html ?? undefined,
+        });
+    }
+    return entries;
+}
+function trimEntryBody(body) {
+    if (body.length <= MAX_ENTRY_BODY_CHARS) {
+        return body;
+    }
+    return `${body.slice(0, MAX_ENTRY_BODY_CHARS)}\n\n[...truncated for prompt size...]`;
+}
+function formatThreadEntry(entry, index) {
+    const source = entry.source === 'issue_body' ? 'Issue description' : `Comment #${entry.id}`;
+    const urlLine = entry.url ? `- URL: ${entry.url}\n` : '';
+    return [
+        `### Entry ${index + 1}`,
+        `- Source: ${source}`,
+        `- Author: ${entry.author}`,
+        `- Created: ${entry.createdAt}`,
+        `${urlLine}Body:`,
+        trimEntryBody(entry.body),
+    ].join('\n');
+}
+function chunkBlocks(blocks, targetChars) {
+    const chunks = [];
+    let current = '';
+    for (const block of blocks) {
+        const next = current ? `${current}\n\n---\n\n${block}` : block;
+        if (next.length > targetChars && current) {
+            chunks.push(current);
+            current = block;
+        }
+        else {
+            current = next;
+        }
+    }
+    if (current) {
+        chunks.push(current);
+    }
+    return chunks;
+}
+export function prepareThreadPrompt(entries, options = {}) {
+    const maxSinglePassChars = options.maxSinglePassChars ?? MAX_SINGLE_PASS_CHARS;
+    const chunkTargetChars = options.chunkTargetChars ?? CHUNK_TARGET_CHARS;
+    const maxChunks = options.maxChunks ?? MAX_CHUNKS;
+    const blocks = entries.map((entry, index) => formatThreadEntry(entry, index));
+    const fullContent = blocks.join('\n\n---\n\n');
+    if (fullContent.length <= maxSinglePassChars) {
+        return {
+            chunked: false,
+            coverageNote: 'Full issue history was included in a single summarization pass.',
+            chunks: [fullContent],
+            totalChunks: 1,
+        };
+    }
+    const generatedChunks = chunkBlocks(blocks, chunkTargetChars);
+    if (generatedChunks.length <= maxChunks) {
+        return {
+            chunked: true,
+            coverageNote: `Thread exceeded single-pass size limits, so it was summarized across ${generatedChunks.length} chunks before final synthesis.`,
+            chunks: generatedChunks,
+            totalChunks: generatedChunks.length,
+        };
+    }
+    const selectedChunks = [generatedChunks[0], ...generatedChunks.slice(-(maxChunks - 1))];
+    return {
+        chunked: true,
+        coverageNote: `Thread exceeded size limits (${generatedChunks.length} chunks). Summary synthesis used chunk 1 and the latest ${maxChunks - 1} chunks.`,
+        chunks: selectedChunks,
+        totalChunks: generatedChunks.length,
+    };
+}

package/sandbox/dist/tasks/issue-summarize/types.js

@@ -0,0 +1 @@
+export {};