@foxden-app/foxclaw 0.5.9 → 0.5.11

package/dist/store/database.js

@@ -98,6 +98,61 @@ export class BridgeStore {
         created_at INTEGER NOT NULL,
         PRIMARY KEY (input_local_id, question_index, message_kind)
       );
+      CREATE TABLE IF NOT EXISTS queued_turn_inputs (
+        queue_id TEXT PRIMARY KEY,
+        scope_id TEXT NOT NULL,
+        chat_id TEXT NOT NULL,
+        chat_type TEXT NOT NULL,
+        topic_id INTEGER,
+        thread_id TEXT NOT NULL,
+        input_json TEXT NOT NULL,
+        source_summary TEXT NOT NULL,
+        message_id INTEGER,
+        status TEXT NOT NULL,
+        error TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        resolved_at INTEGER
+      );
+      CREATE INDEX IF NOT EXISTS queued_turn_inputs_scope_status_idx
+        ON queued_turn_inputs(scope_id, status, created_at);
+      CREATE TABLE IF NOT EXISTS pending_attachment_batches (
+        batch_id TEXT PRIMARY KEY,
+        scope_id TEXT NOT NULL,
+        chat_id TEXT NOT NULL,
+        chat_type TEXT NOT NULL,
+        topic_id INTEGER,
+        thread_id TEXT NOT NULL,
+        cwd TEXT,
+        media_group_id TEXT,
+        attachments_json TEXT NOT NULL,
+        caption TEXT NOT NULL,
+        message_id INTEGER,
+        status TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        resolved_at INTEGER
+      );
+      CREATE INDEX IF NOT EXISTS pending_attachment_batches_scope_status_idx
+        ON pending_attachment_batches(scope_id, status, updated_at);
+      CREATE TABLE IF NOT EXISTS guided_plan_sessions (
+        session_id TEXT PRIMARY KEY,
+        scope_id TEXT NOT NULL,
+        chat_id TEXT NOT NULL,
+        chat_type TEXT NOT NULL,
+        topic_id INTEGER,
+        thread_id TEXT NOT NULL,
+        turn_id TEXT NOT NULL,
+        cwd TEXT,
+        plan_markdown TEXT NOT NULL,
+        message_id INTEGER,
+        state TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        resolved_at INTEGER
+      );
+      CREATE INDEX IF NOT EXISTS guided_plan_sessions_scope_state_idx
+        ON guided_plan_sessions(scope_id, state, updated_at);
       CREATE TABLE IF NOT EXISTS audit_logs (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         direction TEXT NOT NULL,
@@ -438,6 +493,204 @@ export class BridgeStore {
         const row = this.db.prepare('SELECT COUNT(*) AS count FROM pending_user_inputs WHERE resolved_at IS NULL').get();
         return Number(row?.count ?? 0);
     }
+    saveQueuedTurnInput(record) {
+        this.db.prepare(`
+      INSERT INTO queued_turn_inputs (
+        queue_id, scope_id, chat_id, chat_type, topic_id, thread_id, input_json, source_summary,
+        message_id, status, error, created_at, updated_at, resolved_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(queue_id) DO UPDATE SET
+        scope_id = excluded.scope_id,
+        chat_id = excluded.chat_id,
+        chat_type = excluded.chat_type,
+        topic_id = excluded.topic_id,
+        thread_id = excluded.thread_id,
+        input_json = excluded.input_json,
+        source_summary = excluded.source_summary,
+        message_id = excluded.message_id,
+        status = excluded.status,
+        error = excluded.error,
+        created_at = excluded.created_at,
+        updated_at = excluded.updated_at,
+        resolved_at = excluded.resolved_at
+    `).run(record.queueId, record.scopeId, record.chatId, record.chatType, record.topicId, record.threadId, record.inputJson, record.sourceSummary, record.messageId, record.status, record.error, record.createdAt, record.updatedAt, record.resolvedAt);
+    }
+    getQueuedTurnInput(queueId) {
+        const row = this.db.prepare('SELECT * FROM queued_turn_inputs WHERE queue_id = ?').get(queueId);
+        return row ? this.mapQueuedTurnInput(row) : null;
+    }
+    peekQueuedTurnInput(scopeId) {
+        const row = this.db.prepare(`
+      SELECT * FROM queued_turn_inputs
+      WHERE scope_id = ? AND status = 'queued'
+      ORDER BY created_at ASC
+      LIMIT 1
+    `).get(scopeId);
+        return row ? this.mapQueuedTurnInput(row) : null;
+    }
+    listQueuedTurnInputs(scopeId) {
+        const sql = scopeId
+            ? `SELECT * FROM queued_turn_inputs WHERE scope_id = ? AND status IN ('queued', 'processing') ORDER BY created_at ASC`
+            : `SELECT * FROM queued_turn_inputs WHERE status IN ('queued', 'processing') ORDER BY created_at ASC`;
+        const rows = scopeId
+            ? this.db.prepare(sql).all(scopeId)
+            : this.db.prepare(sql).all();
+        return rows.map((row) => this.mapQueuedTurnInput(row));
+    }
+    countQueuedTurnInputs(scopeId) {
+        const row = scopeId
+            ? this.db.prepare(`SELECT COUNT(*) AS count FROM queued_turn_inputs WHERE scope_id = ? AND status IN ('queued', 'processing')`).get(scopeId)
+            : this.db.prepare(`SELECT COUNT(*) AS count FROM queued_turn_inputs WHERE status IN ('queued', 'processing')`).get();
+        return Number(row?.count ?? 0);
+    }
+    updateQueuedTurnInputStatus(queueId, status, error = null) {
+        const resolvedAt = status === 'queued' || status === 'processing' ? null : Date.now();
+        this.db.prepare(`
+      UPDATE queued_turn_inputs
+      SET status = ?, error = ?, updated_at = ?, resolved_at = ?
+      WHERE queue_id = ?
+    `).run(status, error, Date.now(), resolvedAt, queueId);
+    }
+    cancelQueuedTurnInputs(scopeId) {
+        const result = this.db.prepare(`
+      UPDATE queued_turn_inputs
+      SET status = 'cancelled', updated_at = ?, resolved_at = ?
+      WHERE scope_id = ? AND status = 'queued'
+    `).run(Date.now(), Date.now(), scopeId);
+        return Number(result.changes ?? 0);
+    }
+    requeueInterruptedQueuedTurnInputs() {
+        const result = this.db.prepare(`
+      UPDATE queued_turn_inputs
+      SET status = 'queued', error = NULL, updated_at = ?, resolved_at = NULL
+      WHERE status = 'processing'
+    `).run(Date.now());
+        return Number(result.changes ?? 0);
+    }
+    savePendingAttachmentBatch(record) {
+        this.db.prepare(`
+      INSERT INTO pending_attachment_batches (
+        batch_id, scope_id, chat_id, chat_type, topic_id, thread_id, cwd, media_group_id,
+        attachments_json, caption, message_id, status, created_at, updated_at, resolved_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(batch_id) DO UPDATE SET
+        scope_id = excluded.scope_id,
+        chat_id = excluded.chat_id,
+        chat_type = excluded.chat_type,
+        topic_id = excluded.topic_id,
+        thread_id = excluded.thread_id,
+        cwd = excluded.cwd,
+        media_group_id = excluded.media_group_id,
+        attachments_json = excluded.attachments_json,
+        caption = excluded.caption,
+        message_id = excluded.message_id,
+        status = excluded.status,
+        created_at = excluded.created_at,
+        updated_at = excluded.updated_at,
+        resolved_at = excluded.resolved_at
+    `).run(record.batchId, record.scopeId, record.chatId, record.chatType, record.topicId, record.threadId, record.cwd, record.mediaGroupId, record.attachmentsJson, record.caption, record.messageId, record.status, record.createdAt, record.updatedAt, record.resolvedAt);
+    }
+    getPendingAttachmentBatch(batchId) {
+        const row = this.db.prepare('SELECT * FROM pending_attachment_batches WHERE batch_id = ?').get(batchId);
+        return row ? this.mapPendingAttachmentBatch(row) : null;
+    }
+    findPendingAttachmentBatchByMediaGroup(scopeId, mediaGroupId) {
+        const row = this.db.prepare(`
+      SELECT * FROM pending_attachment_batches
+      WHERE scope_id = ? AND media_group_id = ? AND status = 'pending'
+      ORDER BY updated_at DESC
+      LIMIT 1
+    `).get(scopeId, mediaGroupId);
+        return row ? this.mapPendingAttachmentBatch(row) : null;
+    }
+    getLatestPendingAttachmentBatch(scopeId) {
+        const row = this.db.prepare(`
+      SELECT * FROM pending_attachment_batches
+      WHERE scope_id = ? AND status = 'pending'
+      ORDER BY updated_at DESC
+      LIMIT 1
+    `).get(scopeId);
+        return row ? this.mapPendingAttachmentBatch(row) : null;
+    }
+    updatePendingAttachmentBatchMessage(batchId, messageId) {
+        this.db.prepare('UPDATE pending_attachment_batches SET message_id = ?, updated_at = ? WHERE batch_id = ?').run(messageId, Date.now(), batchId);
+    }
+    resolvePendingAttachmentBatch(batchId, status) {
+        this.db.prepare(`
+      UPDATE pending_attachment_batches
+      SET status = ?, updated_at = ?, resolved_at = ?
+      WHERE batch_id = ?
+    `).run(status, Date.now(), Date.now(), batchId);
+    }
+    clearPendingAttachmentBatches(scopeId) {
+        const result = this.db.prepare(`
+      UPDATE pending_attachment_batches
+      SET status = 'cleared', updated_at = ?, resolved_at = ?
+      WHERE scope_id = ? AND status = 'pending'
+    `).run(Date.now(), Date.now(), scopeId);
+        return Number(result.changes ?? 0);
+    }
+    saveGuidedPlanSession(record) {
+        this.db.prepare(`
+      INSERT INTO guided_plan_sessions (
+        session_id, scope_id, chat_id, chat_type, topic_id, thread_id, turn_id, cwd,
+        plan_markdown, message_id, state, created_at, updated_at, resolved_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(session_id) DO UPDATE SET
+        scope_id = excluded.scope_id,
+        chat_id = excluded.chat_id,
+        chat_type = excluded.chat_type,
+        topic_id = excluded.topic_id,
+        thread_id = excluded.thread_id,
+        turn_id = excluded.turn_id,
+        cwd = excluded.cwd,
+        plan_markdown = excluded.plan_markdown,
+        message_id = excluded.message_id,
+        state = excluded.state,
+        created_at = excluded.created_at,
+        updated_at = excluded.updated_at,
+        resolved_at = excluded.resolved_at
+    `).run(record.sessionId, record.scopeId, record.chatId, record.chatType, record.topicId, record.threadId, record.turnId, record.cwd, record.planMarkdown, record.messageId, record.state, record.createdAt, record.updatedAt, record.resolvedAt);
+    }
+    getGuidedPlanSession(sessionId) {
+        const row = this.db.prepare('SELECT * FROM guided_plan_sessions WHERE session_id = ?').get(sessionId);
+        return row ? this.mapGuidedPlanSession(row) : null;
+    }
+    findOpenGuidedPlanSession(scopeId, turnId) {
+        const row = turnId
+            ? this.db.prepare(`
+          SELECT * FROM guided_plan_sessions
+          WHERE scope_id = ? AND turn_id = ? AND state = 'awaiting_confirmation'
+          ORDER BY updated_at DESC
+          LIMIT 1
+        `).get(scopeId, turnId)
+            : this.db.prepare(`
+          SELECT * FROM guided_plan_sessions
+          WHERE scope_id = ? AND state = 'awaiting_confirmation'
+          ORDER BY updated_at DESC
+          LIMIT 1
+        `).get(scopeId);
+        return row ? this.mapGuidedPlanSession(row) : null;
+    }
+    listOpenGuidedPlanSessions() {
+        const rows = this.db.prepare(`
+      SELECT * FROM guided_plan_sessions
+      WHERE state = 'awaiting_confirmation'
+      ORDER BY updated_at ASC
+    `).all();
+        return rows.map((row) => this.mapGuidedPlanSession(row));
+    }
+    updateGuidedPlanSessionMessage(sessionId, messageId) {
+        this.db.prepare('UPDATE guided_plan_sessions SET message_id = ?, updated_at = ? WHERE session_id = ?').run(messageId, Date.now(), sessionId);
+    }
+    updateGuidedPlanSessionState(sessionId, state) {
+        const resolvedAt = state === 'awaiting_confirmation' || state === 'executing' ? null : Date.now();
+        this.db.prepare(`
+      UPDATE guided_plan_sessions
+      SET state = ?, updated_at = ?, resolved_at = ?
+      WHERE session_id = ?
+    `).run(state, Date.now(), resolvedAt, sessionId);
+    }
     insertAudit(direction, chatId, eventType, summary) {
         this.db.prepare('INSERT INTO audit_logs (direction, chat_id, event_type, summary, created_at) VALUES (?, ?, ?, ?, ?)').run(direction, chatId, eventType, summary, Date.now());
     }
@@ -482,6 +735,61 @@ export class BridgeStore {
             resolvedAt: row.resolved_at === null ? null : Number(row.resolved_at),
         };
     }
+    mapQueuedTurnInput(row) {
+        return {
+            queueId: String(row.queue_id),
+            scopeId: String(row.scope_id),
+            chatId: String(row.chat_id),
+            chatType: String(row.chat_type),
+            topicId: row.topic_id === null ? null : Number(row.topic_id),
+            threadId: String(row.thread_id),
+            inputJson: String(row.input_json),
+            sourceSummary: String(row.source_summary),
+            messageId: row.message_id === null ? null : Number(row.message_id),
+            status: normalizeQueuedTurnInputStatus(row.status),
+            error: row.error === null ? null : String(row.error),
+            createdAt: Number(row.created_at),
+            updatedAt: Number(row.updated_at),
+            resolvedAt: row.resolved_at === null ? null : Number(row.resolved_at),
+        };
+    }
+    mapPendingAttachmentBatch(row) {
+        return {
+            batchId: String(row.batch_id),
+            scopeId: String(row.scope_id),
+            chatId: String(row.chat_id),
+            chatType: String(row.chat_type),
+            topicId: row.topic_id === null ? null : Number(row.topic_id),
+            threadId: String(row.thread_id),
+            cwd: row.cwd === null ? null : String(row.cwd),
+            mediaGroupId: row.media_group_id === null ? null : String(row.media_group_id),
+            attachmentsJson: String(row.attachments_json),
+            caption: String(row.caption ?? ''),
+            messageId: row.message_id === null ? null : Number(row.message_id),
+            status: normalizePendingAttachmentBatchStatus(row.status),
+            createdAt: Number(row.created_at),
+            updatedAt: Number(row.updated_at),
+            resolvedAt: row.resolved_at === null ? null : Number(row.resolved_at),
+        };
+    }
+    mapGuidedPlanSession(row) {
+        return {
+            sessionId: String(row.session_id),
+            scopeId: String(row.scope_id),
+            chatId: String(row.chat_id),
+            chatType: String(row.chat_type),
+            topicId: row.topic_id === null ? null : Number(row.topic_id),
+            threadId: String(row.thread_id),
+            turnId: String(row.turn_id),
+            cwd: row.cwd === null ? null : String(row.cwd),
+            planMarkdown: String(row.plan_markdown),
+            messageId: row.message_id === null ? null : Number(row.message_id),
+            state: normalizeGuidedPlanSessionState(row.state),
+            createdAt: Number(row.created_at),
+            updatedAt: Number(row.updated_at),
+            resolvedAt: row.resolved_at === null ? null : Number(row.resolved_at),
+        };
+    }
     writeChatSettings(chatId, model, reasoningEffort, locale, accessPreset, collaborationMode, serviceTier, activeTurnMessageMode) {
         this.db.prepare(`
       INSERT INTO chat_settings (chat_id, model, reasoning_effort, locale, access_preset, collaboration_mode, service_tier, active_turn_message_mode, updated_at)
@@ -615,3 +923,16 @@ function normalizeCollaborationMode(value) {
 function normalizeActiveTurnMessageMode(value) {
     return value === 'steer' || value === 'queue' ? value : null;
 }
+function normalizeQueuedTurnInputStatus(value) {
+    return value === 'processing' || value === 'completed' || value === 'cancelled' || value === 'failed'
+        ? value
+        : 'queued';
+}
+function normalizePendingAttachmentBatchStatus(value) {
+    return value === 'consumed' || value === 'cleared' ? value : 'pending';
+}
+function normalizeGuidedPlanSessionState(value) {
+    return value === 'executing' || value === 'cancelled' || value === 'completed'
+        ? value
+        : 'awaiting_confirmation';
+}

package/dist/telegram/gateway.d.ts

@@ -12,6 +12,7 @@ export interface TelegramTextEvent {
     userId: string;
     text: string;
     messageId: number;
+    mediaGroupId?: string | null;
     attachments: TelegramInboundAttachment[];
     entities: TelegramMessageEntity[];
     replyToBot: boolean;

package/dist/telegram/gateway.js

@@ -245,6 +245,7 @@ export class TelegramGateway extends EventEmitter {
                     userId: String(update.message.from.id),
                     text,
                     messageId: update.message.message_id,
+                    mediaGroupId: update.message.media_group_id ?? null,
                     attachments,
                     entities,
                     replyToBot,

package/dist/types.d.ts

@@ -25,6 +25,58 @@ export interface ChatSessionSettings {
     activeTurnMessageMode: ActiveTurnMessageMode | null;
     updatedAt: number;
 }
+export type QueuedTurnInputStatus = 'queued' | 'processing' | 'completed' | 'cancelled' | 'failed';
+export interface QueuedTurnInputRecord {
+    queueId: string;
+    scopeId: string;
+    chatId: string;
+    chatType: string;
+    topicId: number | null;
+    threadId: string;
+    inputJson: string;
+    sourceSummary: string;
+    messageId: number | null;
+    status: QueuedTurnInputStatus;
+    error: string | null;
+    createdAt: number;
+    updatedAt: number;
+    resolvedAt: number | null;
+}
+export type PendingAttachmentBatchStatus = 'pending' | 'consumed' | 'cleared';
+export interface PendingAttachmentBatchRecord {
+    batchId: string;
+    scopeId: string;
+    chatId: string;
+    chatType: string;
+    topicId: number | null;
+    threadId: string;
+    cwd: string | null;
+    mediaGroupId: string | null;
+    attachmentsJson: string;
+    caption: string;
+    messageId: number | null;
+    status: PendingAttachmentBatchStatus;
+    createdAt: number;
+    updatedAt: number;
+    resolvedAt: number | null;
+}
+export type GuidedPlanSessionState = 'awaiting_confirmation' | 'executing' | 'cancelled' | 'completed';
+export interface GuidedPlanSessionRecord {
+    sessionId: string;
+    scopeId: string;
+    chatId: string;
+    chatType: string;
+    topicId: number | null;
+    threadId: string;
+    turnId: string;
+    cwd: string | null;
+    planMarkdown: string;
+    messageId: number | null;
+    state: GuidedPlanSessionState;
+    createdAt: number;
+    updatedAt: number;
+    resolvedAt: number | null;
+}
 export interface CachedThread {
     index: number;
     threadId: string;
@@ -332,6 +384,7 @@ export interface RuntimeStatus {
     currentBindings: number;
     pendingApprovals: number;
     pendingUserInputs: number;
+    queuedTurns: number;
     activeTurns: number;
     lastError: string | null;
     updatedAt: string;

package/dist/update.d.ts

@@ -7,6 +7,8 @@ export interface SelfUpdateStatus {
     locale: AppLocale;
     fromVersion: string;
     toVersion: string | null;
+    releaseNotes?: string[] | null;
+    releaseNotesVersion?: string | null;
     codexUpdate?: string | null;
     codexFromVersion?: string | null;
     codexToVersion?: string | null;
@@ -74,4 +76,5 @@ export declare function buildSelfUpdateLaunchCommand(options: {
     unitName?: string;
 }): SelfUpdateLaunchCommand;
 export declare function performSelfUpdate(options: PerformSelfUpdateOptions): SelfUpdateOutcome;
+export declare function extractReleaseNotes(changelog: string, version: string, locale: AppLocale): string[] | null;
 export {};

package/dist/update.js

@@ -132,6 +132,10 @@ export function readSelfUpdateStatus(statusFile) {
             locale: parsed.locale,
             fromVersion: parsed.fromVersion,
             toVersion: typeof parsed.toVersion === 'string' ? parsed.toVersion : null,
+            ...(Array.isArray(parsed.releaseNotes) ? {
+                releaseNotes: parsed.releaseNotes.filter((entry) => typeof entry === 'string'),
+            } : {}),
+            ...(typeof parsed.releaseNotesVersion === 'string' ? { releaseNotesVersion: parsed.releaseNotesVersion } : {}),
             ...(typeof parsed.codexUpdate === 'string' ? { codexUpdate: parsed.codexUpdate } : {}),
             ...(typeof parsed.codexFromVersion === 'string' ? { codexFromVersion: parsed.codexFromVersion } : {}),
             ...(typeof parsed.codexToVersion === 'string' ? { codexToVersion: parsed.codexToVersion } : {}),
@@ -185,6 +189,8 @@ export function createSelfUpdateRuntime(options) {
                 locale,
                 fromVersion: options.version,
                 toVersion: null,
+                releaseNotes: null,
+                releaseNotesVersion: null,
                 codexUpdate: null,
                 codexFromVersion: null,
                 codexToVersion: null,
@@ -229,6 +235,8 @@ export function createSelfUpdateRuntime(options) {
                     locale,
                     fromVersion: options.version,
                     toVersion: null,
+                    releaseNotes: null,
+                    releaseNotesVersion: null,
                     codexUpdate: null,
                     codexFromVersion: null,
                     codexToVersion: null,
@@ -296,9 +304,10 @@ export function performSelfUpdate(options) {
         runInherited(installer.command, installer.installArgs, installerEnv);
         const updatedEntryPoint = resolveUpdatedEntryPoint(installer, installerEnv);
         toVersion = readInstalledPackageVersion(updatedEntryPoint);
+        const releaseNotes = readInstalledReleaseNotes(updatedEntryPoint, toVersion, options.notificationFile);
         console.log('[UPDATE] Running checks and restarting the FoxClaw service...');
         runInherited(options.nodePath, [updatedEntryPoint, 'start'], installerEnv);
-        completeNotification(options.notificationFile, 'succeeded', toVersion, codexUpdate, null);
+        completeNotification(options.notificationFile, 'succeeded', toVersion, codexUpdate, null, releaseNotes);
         console.log(`[OK] FoxClaw updated and restarted: ${options.version} -> ${toVersion}`);
         return {
             ok: true,
@@ -309,7 +318,7 @@ export function performSelfUpdate(options) {
     }
     catch (error) {
         const message = formatError(error);
-        completeNotification(options.notificationFile, 'failed', toVersion, codexUpdate, message);
+        completeNotification(options.notificationFile, 'failed', toVersion, codexUpdate, message, null);
         console.error(`[FAIL] FoxClaw update failed: ${message}`);
         return {
             ok: false,
@@ -456,7 +465,65 @@ function readInstalledPackageVersion(updatedEntryPoint) {
         return 'unknown';
     }
 }
-function completeNotification(notificationFile, state, toVersion, codexUpdate, error) {
+function readInstalledReleaseNotes(updatedEntryPoint, version, notificationFile) {
+    if (!version || version === 'unknown') {
+        return null;
+    }
+    const pending = notificationFile ? readSelfUpdateStatus(notificationFile) : null;
+    const locale = pending?.locale ?? 'zh';
+    const changelogPath = path.resolve(path.dirname(updatedEntryPoint), '..', 'CHANGELOG.md');
+    try {
+        return extractReleaseNotes(fs.readFileSync(changelogPath, 'utf8'), version, locale);
+    }
+    catch {
+        return null;
+    }
+}
+export function extractReleaseNotes(changelog, version, locale) {
+    const escapedVersion = escapeRegExp(version.replace(/^v/i, ''));
+    const versionHeadingPattern = new RegExp(`^##\\s+\\[?v?${escapedVersion}\\]?\\b.*$`, 'im');
+    const versionMatch = versionHeadingPattern.exec(changelog);
+    if (!versionMatch || versionMatch.index === undefined) {
+        return null;
+    }
+    const sectionStart = versionMatch.index + versionMatch[0].length;
+    const nextHeadingMatch = /^##\s+/m.exec(changelog.slice(sectionStart));
+    const versionSection = nextHeadingMatch
+        ? changelog.slice(sectionStart, sectionStart + nextHeadingMatch.index)
+        : changelog.slice(sectionStart);
+    const localizedSection = extractLocalizedReleaseNoteSection(versionSection, locale) ?? versionSection;
+    const bullets = localizedSection
+        .split(/\r?\n/)
+        .map(line => line.trim())
+        .filter(line => /^[-*]\s+/.test(line))
+        .map(line => line.replace(/^[-*]\s+/, '').trim())
+        .filter(Boolean)
+        .slice(0, 8);
+    return bullets.length > 0 ? bullets : null;
+}
+function extractLocalizedReleaseNoteSection(section, locale) {
+    const headingPattern = /^###\s+(.+)$/gm;
+    const headings = [...section.matchAll(headingPattern)];
+    if (headings.length === 0) {
+        return null;
+    }
+    const preferred = locale === 'zh' ? ['中文', 'Chinese'] : ['English', '英文'];
+    for (let index = 0; index < headings.length; index += 1) {
+        const heading = headings[index];
+        const headingText = heading[1].trim().toLowerCase();
+        if (!preferred.some(label => headingText === label.toLowerCase())) {
+            continue;
+        }
+        const start = heading.index + heading[0].length;
+        const next = headings[index + 1];
+        return next ? section.slice(start, next.index) : section.slice(start);
+    }
+    return null;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function completeNotification(notificationFile, state, toVersion, codexUpdate, error, releaseNotes) {
     if (!notificationFile) {
         return;
     }
@@ -468,6 +535,8 @@ function completeNotification(notificationFile, state, toVersion, codexUpdate, e
         ...pending,
         state,
         toVersion,
+        releaseNotes,
+        releaseNotesVersion: releaseNotes && toVersion ? toVersion : null,
         codexUpdate: codexUpdate?.message ?? null,
         codexFromVersion: codexUpdate?.fromVersion ?? null,
         codexToVersion: codexUpdate?.toVersion ?? null,