team-toon-tack 3.2.10 → 3.2.11

package/dist/scripts/done-job.js

@@ -105,6 +105,7 @@ async function doneJob() {
     const statusSource = localConfig.status_source || "remote";
     const sourceType = getSourceType(config);
     const sourceId = task.sourceId ?? task.linearId;
+    let completionResult = null;
     if (sourceId && statusSource === "remote") {
         // Build completion context
         const context = {
@@ -116,10 +117,15 @@ async function doneJob() {
         };
         // Branch based on source type
         if (sourceType === "trello") {
-            await handleTrelloCompletion(context);
+            completionResult = await handleTrelloCompletion(context);
         }
         else {
-            await handleLinearCompletion(context);
+            completionResult = await handleLinearCompletion(context);
+        }
+        if (!completionResult.success) {
+            console.error(completionResult.message ||
+                `Failed to update remote status for ${task.id}.`);
+            process.exit(1);
         }
     }
     else if (statusSource === "local") {
@@ -136,6 +142,11 @@ async function doneJob() {
         });
         if (syncedTask) {
             console.log(`Synced: ${syncedTask.id} → ${syncedTask.status} (local: ${syncedTask.localStatus})`);
+            if (completionResult?.status &&
+                syncedTask.status !== completionResult.status) {
+                console.error(`Remote status verification failed for ${task.id}: expected ${completionResult.status}, got ${syncedTask.status}.`);
+                process.exit(1);
+            }
         }
     }
     else {

package/dist/scripts/lib/adapters/linear-adapter.js

@@ -208,7 +208,15 @@ export class LinearAdapter {
     }
     async updateIssueStatus(sourceId, statusId) {
         try {
-            await this.client.updateIssue(sourceId, { stateId: statusId });
+            const payload = await this.client.updateIssue(sourceId, {
+                stateId: statusId,
+            });
+            if (!payload.success) {
+                return {
+                    success: false,
+                    error: `Linear mutation returned success=false for ${sourceId}`,
+                };
+            }
             return { success: true };
         }
         catch (e) {

package/dist/scripts/lib/done/linear-handler.js

@@ -16,6 +16,13 @@ async function handleSimpleCompletion(context) {
     if (success) {
         console.log(`Linear: ${task.id} → ${transitions.done}`);
     }
+    else {
+        return {
+            success: false,
+            status: task.status,
+            message: `Failed to move ${task.id} to ${transitions.done}`,
+        };
+    }
     // Also mark parent as done if exists
     if (task.parentIssueId) {
         const result = await updateParentStatus(task.parentIssueId, transitions.done, localConfig.qa_pm_teams, config);
@@ -39,6 +46,13 @@ async function handleStrictReview(context) {
         if (success) {
             console.log(`Linear: ${task.id} → ${devTestingStatus}`);
         }
+        else {
+            return {
+                success: false,
+                status: task.status,
+                message: `Failed to move ${task.id} to ${devTestingStatus}`,
+            };
+        }
         // Also mark parent to testing if exists
         if (task.parentIssueId && localConfig.qa_pm_teams?.length) {
             const result = await updateParentToTesting(task.parentIssueId, localConfig.qa_pm_teams, config);
@@ -54,6 +68,13 @@ async function handleStrictReview(context) {
     if (success) {
         console.log(`Linear: ${task.id} → ${transitions.done}`);
     }
+    else {
+        return {
+            success: false,
+            status: task.status,
+            message: `Failed to move ${task.id} to ${transitions.done}`,
+        };
+    }
     return { success: true, status: transitions.done };
 }
 /**
@@ -87,8 +108,20 @@ async function handleUpstreamCompletion(context, isStrict) {
         const fallbackSuccess = await updateIssueStatus(task.linearId, devTestingStatus, config, localConfig.team);
         if (fallbackSuccess) {
             console.log(`Linear: ${task.id} → ${devTestingStatus} (fallback, no valid parent)`);
+            return { success: true, status: devTestingStatus };
         }
-        return { success: true, status: devTestingStatus };
+        return {
+            success: false,
+            status: task.status,
+            message: `Failed to move ${task.id} to ${devTestingStatus}`,
+        };
+    }
+    if (!doneSuccess) {
+        return {
+            success: false,
+            status: task.status,
+            message: `Failed to move ${task.id} to ${transitions.done}`,
+        };
     }
     return { success: true, status: transitions.done };
 }
@@ -121,7 +154,7 @@ export async function handleLinearCompletion(context) {
             result = await handleSimpleCompletion(context);
     }
     // Add comment with commit info (only if promptMessage provided)
-    if (commit && promptMessage) {
+    if (result.success && commit && promptMessage) {
         const commentBody = buildCompletionComment(commit, promptMessage);
         const commentSuccess = await addComment(task.linearId, commentBody);
         if (commentSuccess) {

package/dist/scripts/lib/done/trello-handler.js

@@ -31,6 +31,12 @@ export async function handleTrelloCompletion(context) {
         if (result.success) {
             console.log(`Trello: ${task.id} → ${transitions.done}`);
         }
+        else {
+            return {
+                success: false,
+                message: result.error || `Failed to move ${task.id} to ${transitions.done}`,
+            };
+        }
         // Add comment with commit info (only if promptMessage provided)
         if (commit && promptMessage) {
             const commentBody = buildCompletionComment(commit, promptMessage);

package/dist/scripts/lib/files.d.ts

@@ -1,9 +1,15 @@
 export declare function isLinearImageUrl(url: string): boolean;
+export declare function isTrelloFileUrl(url: string): boolean;
+/**
+ * Extract image/file URLs from markdown text (description, comments)
+ */
+export declare function extractImageUrls(text: string): string[];
 /**
  * Extract Linear image URLs from markdown text (description, comments)
  */
 export declare function extractLinearImageUrls(text: string): string[];
 export declare function downloadLinearFile(url: string, issueId: string, attachmentId: string, outputDir: string): Promise<string | undefined>;
+export declare function downloadTrelloFile(url: string, issueId: string, attachmentId: string, outputDir: string): Promise<string | undefined>;
 export declare const downloadLinearImage: typeof downloadLinearFile;
 export declare function clearIssueImages(outputDir: string, issueId: string): Promise<void>;
 export declare function ensureOutputDir(outputDir: string): Promise<void>;

package/dist/scripts/lib/files.js

@@ -4,6 +4,12 @@ const LINEAR_IMAGE_DOMAINS = [
     "uploads.linear.app",
     "linear-uploads.s3.us-west-2.amazonaws.com",
 ];
+const TRELLO_FILE_DOMAINS = [
+    "trello.com",
+    "api.trello.com",
+    "attachments.trello.com",
+];
+const IMAGE_EXTENSIONS = /\.(jpg|jpeg|png|gif|webp|svg)(?:$|[?#])/i;
 export function isLinearImageUrl(url) {
     try {
         const parsed = new URL(url);
@@ -13,21 +19,40 @@ export function isLinearImageUrl(url) {
         return false;
     }
 }
+export function isTrelloFileUrl(url) {
+    try {
+        const parsed = new URL(url);
+        return TRELLO_FILE_DOMAINS.some((domain) => parsed.host.includes(domain));
+    }
+    catch {
+        return false;
+    }
+}
+function isLikelyImageUrl(url) {
+    try {
+        const parsed = new URL(url);
+        return (IMAGE_EXTENSIONS.test(parsed.pathname) ||
+            isLinearImageUrl(url) ||
+            isTrelloFileUrl(url));
+    }
+    catch {
+        return false;
+    }
+}
 /**
- * Extract Linear image URLs from markdown text (description, comments)
+ * Extract image/file URLs from markdown text (description, comments)
  */
-export function extractLinearImageUrls(text) {
+export function extractImageUrls(text) {
     const urls = [];
-    // Match markdown image syntax ![alt](url) and plain URLs
     const patterns = [
-        /!\[[^\]]*\]\((https?:\/\/[^)]+)\)/g, // ![alt](url)
-        /(https?:\/\/uploads\.linear\.app\/[^\s)>\]]+)/g, // Plain Linear upload URLs
+        /!\[[^\]]*\]\((https?:\/\/[^)]+)\)/g,
+        /(https?:\/\/[^\s)>\]]+)/g,
     ];
     for (const pattern of patterns) {
         let match = pattern.exec(text);
         while (match) {
             const url = match[1];
-            if (isLinearImageUrl(url) && !urls.includes(url)) {
+            if (isLikelyImageUrl(url) && !urls.includes(url)) {
                 urls.push(url);
             }
             match = pattern.exec(text);
@@ -35,6 +60,12 @@ export function extractLinearImageUrls(text) {
     }
     return urls;
 }
+/**
+ * Extract Linear image URLs from markdown text (description, comments)
+ */
+export function extractLinearImageUrls(text) {
+    return extractImageUrls(text).filter((url) => isLinearImageUrl(url));
+}
 // MIME type to extension mapping
 const MIME_TO_EXT = {
     // Images
@@ -90,20 +121,17 @@ function getFileExtension(url, contentType) {
     // Last resort: unknown binary
     return { ext: "bin", isImage: false };
 }
-export async function downloadLinearFile(url, issueId, attachmentId, outputDir) {
+async function downloadRemoteFile(url, issueId, attachmentId, outputDir, options) {
     try {
-        // Linear files require authentication
-        const headers = {};
-        if (process.env.LINEAR_API_KEY) {
-            headers.Authorization = process.env.LINEAR_API_KEY;
-        }
-        const response = await fetch(url, { headers });
+        const downloadUrl = options?.transformUrl ? options.transformUrl(url) : url;
+        const headers = options?.headers ?? {};
+        const response = await fetch(downloadUrl, { headers });
         if (!response.ok) {
             console.error(`Failed to download file: ${response.status}`);
             return undefined;
         }
         const contentType = response.headers.get("content-type") || undefined;
-        const { ext } = getFileExtension(url, contentType);
+        const { ext } = getFileExtension(downloadUrl, contentType);
         const filename = `${issueId}_${attachmentId}.${ext}`;
         const filepath = path.join(outputDir, filename);
         const buffer = await response.arrayBuffer();
@@ -115,6 +143,32 @@ export async function downloadLinearFile(url, issueId, attachmentId, outputDir)
         return undefined;
     }
 }
+export async function downloadLinearFile(url, issueId, attachmentId, outputDir) {
+    const headers = {};
+    if (process.env.LINEAR_API_KEY && isLinearImageUrl(url)) {
+        headers.Authorization = process.env.LINEAR_API_KEY;
+    }
+    return downloadRemoteFile(url, issueId, attachmentId, outputDir, {
+        headers,
+    });
+}
+export async function downloadTrelloFile(url, issueId, attachmentId, outputDir) {
+    return downloadRemoteFile(url, issueId, attachmentId, outputDir, {
+        transformUrl: (rawUrl) => {
+            if (!isTrelloFileUrl(rawUrl)) {
+                return rawUrl;
+            }
+            const parsed = new URL(rawUrl);
+            if (process.env.TRELLO_API_KEY && !parsed.searchParams.has("key")) {
+                parsed.searchParams.set("key", process.env.TRELLO_API_KEY);
+            }
+            if (process.env.TRELLO_TOKEN && !parsed.searchParams.has("token")) {
+                parsed.searchParams.set("token", process.env.TRELLO_TOKEN);
+            }
+            return parsed.toString();
+        },
+    });
+}
 // Alias for backwards compatibility
 export const downloadLinearImage = downloadLinearFile;
 export async function clearIssueImages(outputDir, issueId) {

package/dist/scripts/lib/linear.js

@@ -26,7 +26,13 @@ export async function updateIssueStatus(linearId, targetStatusName, config, team
         const states = await getWorkflowStates(config, teamKey);
         const targetState = states.find((s) => s.name === targetStatusName);
         if (targetState) {
-            await client.updateIssue(linearId, { stateId: targetState.id });
+            const payload = await client.updateIssue(linearId, {
+                stateId: targetState.id,
+            });
+            if (!payload.success) {
+                console.error(`Failed to update Linear: mutation returned success=false for ${linearId} → ${targetStatusName}`);
+                return false;
+            }
             return true;
         }
         return false;

package/dist/scripts/lib/status-helpers.d.ts

@@ -2,7 +2,7 @@
  * Helper functions for status transitions
  * Handles the case where `todo` can be string | string[]
  */
-import type { StatusTransitions } from "../utils.js";
+import type { LocalConfig, StatusTransitions, Task } from "../utils.js";
 /**
  * Normalize todo status value to array
  * Only `todo` supports multiple values for sync filtering
@@ -16,10 +16,21 @@ export declare function isTodoStatus(statusName: string, transitions: StatusTran
  * Get all statuses to sync (flattens todo array + in_progress)
  */
 export declare function getSyncStatuses(transitions: StatusTransitions): string[];
+/**
+ * Collect all statuses that should be treated as "in review"
+ * This includes the generic testing transition plus any team-specific testing
+ * statuses chosen during init/config.
+ */
+export declare function getReviewStatuses(transitions: StatusTransitions, localConfig?: LocalConfig): string[];
 /**
  * Map remote status to local status using transitions
  */
-export declare function mapRemoteToLocalStatus(remoteStatus: string, transitions: StatusTransitions): "pending" | "in-progress" | "completed" | "in-review" | "blocked";
+export declare function mapRemoteToLocalStatus(remoteStatus: string, transitions: StatusTransitions, localConfig?: LocalConfig): "pending" | "in-progress" | "completed" | "in-review" | "blocked";
+/**
+ * Preserve optimistic local progress for active tasks, but let explicit
+ * remote review/completed/blocked states override stale local state.
+ */
+export declare function resolveLocalStatus(existingLocalStatus: Task["localStatus"] | undefined, remoteStatus: string, transitions: StatusTransitions, localConfig?: LocalConfig): Task["localStatus"];
 /**
  * Format todo status for display (handles string | string[])
  */

package/dist/scripts/lib/status-helpers.js

@@ -24,17 +24,37 @@ export function isTodoStatus(statusName, transitions) {
 export function getSyncStatuses(transitions) {
     return [...normalizeTodoStatuses(transitions.todo), transitions.in_progress];
 }
+/**
+ * Collect all statuses that should be treated as "in review"
+ * This includes the generic testing transition plus any team-specific testing
+ * statuses chosen during init/config.
+ */
+export function getReviewStatuses(transitions, localConfig) {
+    const statuses = new Set();
+    if (transitions.testing) {
+        statuses.add(transitions.testing);
+    }
+    if (localConfig?.dev_testing_status) {
+        statuses.add(localConfig.dev_testing_status);
+    }
+    for (const team of localConfig?.qa_pm_teams ?? []) {
+        if (team.testing_status) {
+            statuses.add(team.testing_status);
+        }
+    }
+    return [...statuses];
+}
 /**
  * Map remote status to local status using transitions
  */
-export function mapRemoteToLocalStatus(remoteStatus, transitions) {
+export function mapRemoteToLocalStatus(remoteStatus, transitions, localConfig) {
     if (remoteStatus === transitions.done) {
         return "completed";
     }
     if (remoteStatus === transitions.in_progress) {
         return "in-progress";
     }
-    if (transitions.testing && remoteStatus === transitions.testing) {
+    if (getReviewStatuses(transitions, localConfig).includes(remoteStatus)) {
         return "in-review";
     }
     if (transitions.blocked && remoteStatus === transitions.blocked) {
@@ -42,6 +62,22 @@ export function mapRemoteToLocalStatus(remoteStatus, transitions) {
     }
     return "pending";
 }
+/**
+ * Preserve optimistic local progress for active tasks, but let explicit
+ * remote review/completed/blocked states override stale local state.
+ */
+export function resolveLocalStatus(existingLocalStatus, remoteStatus, transitions, localConfig) {
+    const remoteLocalStatus = mapRemoteToLocalStatus(remoteStatus, transitions, localConfig);
+    if (!existingLocalStatus) {
+        return remoteLocalStatus;
+    }
+    if (remoteLocalStatus === "in-review" ||
+        remoteLocalStatus === "completed" ||
+        remoteLocalStatus === "blocked") {
+        return remoteLocalStatus;
+    }
+    return existingLocalStatus;
+}
 /**
  * Format todo status for display (handles string | string[])
  */

package/dist/scripts/lib/sync.js

@@ -62,7 +62,7 @@ export async function fetchIssueDetail(issueId, options = {}) {
  * Returns the updated task or null if issue not found
  */
 export async function syncSingleIssue(issueId, options) {
-    const { config, localConfig: _localConfig, preserveLocalStatus = true, } = options;
+    const { config, localConfig, preserveLocalStatus = true, } = options;
     const client = options.client ?? getLinearClient();
     // Fetch issue details using shared function
     const task = await fetchIssueDetail(issueId, { client });
@@ -81,7 +81,7 @@ export async function syncSingleIssue(issueId, options) {
     // Map remote status to local status if not preserving
     if (!preserveLocalStatus) {
         const transitions = getStatusTransitions(config);
-        task.localStatus = mapRemoteToLocalStatus(task.status, transitions);
+        task.localStatus = mapRemoteToLocalStatus(task.status, transitions, localConfig);
     }
     // Update cycle data
     if (existingData) {

package/dist/scripts/sync.js

@@ -1,7 +1,31 @@
 import { createAdapter } from "./lib/adapters/index.js";
-import { clearAllOutput, clearIssueImages, downloadLinearImage, ensureOutputDir, extractLinearImageUrls, isLinearImageUrl, } from "./lib/files.js";
-import { getSyncStatuses } from "./lib/status-helpers.js";
+import { clearAllOutput, clearIssueImages, downloadLinearImage, downloadTrelloFile, ensureOutputDir, extractImageUrls, isLinearImageUrl, } from "./lib/files.js";
+import { getReviewStatuses, getSyncStatuses, resolveLocalStatus, } from "./lib/status-helpers.js";
 import { getLinearClient, getPaths, getPrioritySortIndex, getSourceType, getTeamId, loadConfig, loadCycleData, loadLocalConfig, saveConfig, saveCycleData, } from "./utils.js";
+async function downloadEmbeddedImages(texts, issueId, attachments, outputDir, downloadFile, titlePrefix, sourceType, filterUrl) {
+    let imageIndex = 0;
+    for (const text of texts) {
+        if (!text)
+            continue;
+        for (const url of extractImageUrls(text)) {
+            if (filterUrl && !filterUrl(url))
+                continue;
+            if (attachments.some((a) => a.url === url))
+                continue;
+            const attachmentId = `${titlePrefix.toLowerCase()}_${imageIndex++}`;
+            const localPath = await downloadFile(url, issueId, attachmentId, outputDir);
+            if (localPath) {
+                attachments.push({
+                    id: attachmentId,
+                    title: `${titlePrefix} Image`,
+                    url,
+                    sourceType,
+                    localPath,
+                });
+            }
+        }
+    }
+}
 async function sync() {
     const args = process.argv.slice(2);
     // Handle help flag
@@ -148,7 +172,12 @@ Examples:
             }
             if (targetStateId) {
                 try {
-                    await client.updateIssue(task.linearId, { stateId: targetStateId });
+                    const payload = await client.updateIssue(task.linearId, {
+                        stateId: targetStateId,
+                    });
+                    if (!payload.success) {
+                        throw new Error("Linear mutation returned success=false");
+                    }
                     const targetName = targetStateId === inProgressStateId
                         ? statusTransitions.in_progress
                         : statusTransitions.testing;
@@ -257,29 +286,6 @@ Examples:
             }
             attachments.push(attachment);
         }
-        // Extract and download images from description
-        if (issue.description) {
-            const descriptionImageUrls = extractLinearImageUrls(issue.description);
-            for (const url of descriptionImageUrls) {
-                // Generate a short ID from URL (last segment of path)
-                const urlPath = new URL(url).pathname;
-                const segments = urlPath.split("/").filter(Boolean);
-                const imageId = segments[segments.length - 1] || `desc_${Date.now()}`;
-                // Skip if already in attachments
-                if (attachments.some((a) => a.url === url))
-                    continue;
-                const localPath = await downloadLinearImage(url, issue.identifier, imageId, outputPath);
-                if (localPath) {
-                    attachments.push({
-                        id: imageId,
-                        title: `Description Image`,
-                        url: url,
-                        sourceType: "description",
-                        localPath: localPath,
-                    });
-                }
-            }
-        }
         // Build comments list
         const comments = await Promise.all(commentsData.nodes.map(async (c) => {
             const user = await c.user;
@@ -290,42 +296,41 @@ Examples:
                 user: user?.displayName ?? user?.email,
             };
         }));
+        await downloadEmbeddedImages([
+            issue.description ?? undefined,
+            ...comments
+                .map((comment) => comment.body)
+                .filter((body) => Boolean(body)),
+        ], issue.identifier, attachments, outputPath, downloadLinearImage, "Embedded", "description", isLinearImageUrl);
         let localStatus = "pending";
         // Preserve local status & sync completed tasks to Linear
         if (existingTasksMap.has(issue.identifier)) {
             const existing = existingTasksMap.get(issue.identifier);
-            localStatus = existing?.localStatus ?? "pending";
+            localStatus = resolveLocalStatus(existing?.localStatus, state?.name ?? "", statusTransitions, localConfig);
             if (localStatus === "completed" && state && testingStateId) {
                 // Skip if already in terminal states (done, testing, or cancelled type)
-                const terminalStates = [statusTransitions.done];
-                if (statusTransitions.testing)
-                    terminalStates.push(statusTransitions.testing);
+                const terminalStates = [
+                    statusTransitions.done,
+                    ...getReviewStatuses(statusTransitions, localConfig),
+                ];
                 const isTerminal = terminalStates.includes(state.name) || state.type === "cancelled";
                 if (!isTerminal) {
                     console.log(`Updating ${issue.identifier} to ${statusTransitions.testing} in Linear...`);
-                    await client.updateIssue(issue.id, { stateId: testingStateId });
+                    const payload = await client.updateIssue(issue.id, {
+                        stateId: testingStateId,
+                    });
+                    if (!payload.success) {
+                        throw new Error("Linear mutation returned success=false");
+                    }
                     updatedCount++;
                 }
             }
         }
         else if (state) {
-            // New task: infer localStatus from remote status
-            if (state.name === statusTransitions.in_progress) {
-                localStatus = "in-progress";
-            }
-            else if (statusTransitions.testing &&
-                state.name === statusTransitions.testing) {
-                localStatus = "in-review";
-            }
-            else if (state.name === statusTransitions.done ||
-                state.type === "completed") {
+            localStatus = resolveLocalStatus(undefined, state.name, statusTransitions, localConfig);
+            if (state.type === "completed") {
                 localStatus = "completed";
             }
-            else if (statusTransitions.blocked &&
-                state.name === statusTransitions.blocked) {
-                localStatus = "blocked";
-            }
-            // Default "pending" for todo or other states
         }
         const task = {
             id: issue.identifier,
@@ -501,29 +506,39 @@ async function syncTrello(config, localConfig, options) {
         }
         // Fetch full issue details (comments, attachments) per card
         const fullIssue = await adapter.getIssue(issue.sourceId);
+        const comments = fullIssue?.comments?.map((c) => ({
+            id: c.id,
+            body: c.body,
+            createdAt: c.createdAt,
+            user: c.user,
+        })) ?? [];
+        const attachments = fullIssue?.attachments?.map((a) => ({
+            id: a.id,
+            title: a.title,
+            url: a.url,
+            sourceType: a.sourceType,
+        })) ?? [];
+        await clearIssueImages(outputPath, issue.id);
+        for (const attachment of attachments) {
+            const localPath = await downloadTrelloFile(attachment.url, issue.id, attachment.id, outputPath);
+            if (localPath) {
+                attachment.localPath = localPath;
+            }
+        }
+        await downloadEmbeddedImages([
+            fullIssue?.description ?? issue.description,
+            ...comments
+                .map((comment) => comment.body)
+                .filter((body) => Boolean(body)),
+        ], issue.id, attachments, outputPath, downloadTrelloFile, "Trello", "trello");
         // Preserve local status or infer from remote status
         let localStatus = "pending";
         if (existingTasksMap.has(issue.id)) {
             const existing = existingTasksMap.get(issue.id);
-            localStatus = existing?.localStatus ?? "pending";
+            localStatus = resolveLocalStatus(existing?.localStatus, issue.status, statusTransitions, localConfig);
         }
         else {
-            // New task: infer localStatus from remote status
-            if (issue.status === statusTransitions.in_progress) {
-                localStatus = "in-progress";
-            }
-            else if (statusTransitions.testing &&
-                issue.status === statusTransitions.testing) {
-                localStatus = "in-review";
-            }
-            else if (issue.status === statusTransitions.done) {
-                localStatus = "completed";
-            }
-            else if (statusTransitions.blocked &&
-                issue.status === statusTransitions.blocked) {
-                localStatus = "blocked";
-            }
-            // Default "pending" for todo or other states
+            localStatus = resolveLocalStatus(undefined, issue.status, statusTransitions, localConfig);
         }
         const task = {
             id: issue.id,
@@ -539,18 +554,8 @@ async function syncTrello(config, localConfig, options) {
             description: issue.description,
             parentIssueId: issue.parentIssueId,
             url: issue.url,
-            attachments: fullIssue?.attachments?.map((a) => ({
-                id: a.id,
-                title: a.title,
-                url: a.url,
-                sourceType: a.sourceType,
-            })),
-            comments: fullIssue?.comments?.map((c) => ({
-                id: c.id,
-                body: c.body,
-                createdAt: c.createdAt,
-                user: c.user,
-            })),
+            attachments: attachments.length > 0 ? attachments : undefined,
+            comments: comments.length > 0 ? comments : undefined,
         };
         tasks.push(task);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "team-toon-tack",
-	"version": "3.2.10",
+	"version": "3.2.11",
 	"description": "Linear & Trello task sync & management CLI with TOON format",
 	"type": "module",
 	"bin": {