@frase/mcp-server 0.3.0 → 0.3.2

package/dist/tools/content.js

@@ -1,6 +1,13 @@
 /**
  * Content tools
  */
+/**
+ * Detect whether body content is HTML (vs plain markdown).
+ * Checks for common HTML block-level tags that indicate HTML authoring.
+ */
+function isHtmlContent(text) {
+    return /<(h[1-6]|p|div|ul|ol|table|section|article|blockquote)\b/i.test(text);
+}
 /**
  * Convert HTML body to readable markdown-like text.
  * Preserves headings, paragraphs, lists, and links while stripping raw HTML.
@@ -9,7 +16,7 @@
 function htmlToReadableText(html) {
     let text = html;
     // Convert headings to markdown
-    text = text.replace(/<h([1-6])[^>]*>(.*?)<\/h[1-6]>/gi, (_m, level, content) => {
+    text = text.replace(/<h([1-6])[^>]*>(.*?)<\/h[1-6]>/gis, (_m, level, content) => {
         return "\n" + "#".repeat(parseInt(level)) + " " + content.trim() + "\n";
     });
     // Convert <br> to newlines
@@ -21,15 +28,27 @@ function htmlToReadableText(html) {
     text = text.replace(/<li[^>]*>/gi, "- ");
     text = text.replace(/<\/li>/gi, "\n");
     // Convert <a> to markdown links
-    text = text.replace(/<a[^>]*href="([^"]*)"[^>]*>(.*?)<\/a>/gi, "[$2]($1)");
+    text = text.replace(/<a[^>]*href="([^"]*)"[^>]*>(.*?)<\/a>/gis, "[$2]($1)");
     // Convert bold/italic
-    text = text.replace(/<(strong|b)[^>]*>(.*?)<\/(strong|b)>/gi, "**$2**");
-    text = text.replace(/<(em|i)[^>]*>(.*?)<\/(em|i)>/gi, "*$2*");
+    text = text.replace(/<(strong|b)[^>]*>(.*?)<\/(strong|b)>/gis, "**$2**");
+    text = text.replace(/<(em|i)[^>]*>(.*?)<\/(em|i)>/gis, "*$2*");
     // Convert blockquotes
     text = text.replace(/<blockquote[^>]*>(.*?)<\/blockquote>/gis, "> $1\n");
+    // Convert tables (PRO-1866)
+    text = text.replace(/<\/tr>/gi, "\n");
+    text = text.replace(/<tr[^>]*>/gi, "");
+    text = text.replace(/<t[dh][^>]*>([\s\S]*?)<\/t[dh]>/gi, "$1\t");
+    text = text.replace(/<\/?(?:table|thead|tbody|tfoot|colgroup|col|caption)[^>]*>/gi, "\n");
+    // Convert code blocks (PRO-1866)
+    text = text.replace(/<pre[^>]*><code[^>]*>([\s\S]*?)<\/code><\/pre>/gi, "\n```\n$1\n```\n");
+    text = text.replace(/<code[^>]*>(.*?)<\/code>/gis, "`$1`");
+    // Convert figure captions (PRO-1866)
+    text = text.replace(/<figcaption[^>]*>(.*?)<\/figcaption>/gis, "_$1_\n");
     // Add spacing around div/section blocks to prevent text running together
     text = text.replace(/<\/(div|section|article|aside|header|footer|figure|figcaption)>/gi, "\n");
     text = text.replace(/<(div|section|article|aside|header|footer|figure|figcaption)[^>]*>/gi, "\n");
+    // Preserve angle-bracket URLs before stripping remaining tags (PRO-1866)
+    text = text.replace(/<(https?:\/\/[^>]+)>/g, '$1');
     // Strip remaining HTML tags
     text = text.replace(/<[^>]+>/g, "");
     // Decode common HTML entities
@@ -48,15 +67,24 @@ import { formatTable, formatStatus, formatDate, formatPagination, formatKeyValue
 // ============================================
 // list_content
 // ============================================
+// Display status values matching the Frase web app
+const CONTENT_DISPLAY_STATUS_VALUES = ["drafting", "review", "published", "archived"];
+// Map display status → database content status(es)
+const CONTENT_STATUS_DISPLAY_TO_DB = {
+    drafting: ["draft", "generating"],
+    review: ["review"],
+    published: ["published"],
+    archived: ["archived"],
+};
 const listContentInputSchema = z.object({
     page: z.number().min(1).optional().default(1),
     page_size: z.number().min(1).max(100).optional().default(20),
-    status: z.enum(["draft", "generating", "review", "published", "archived"]).optional(),
+    status: z.enum(CONTENT_DISPLAY_STATUS_VALUES).optional(),
     site_id: z.string().optional(),
 });
 export const listContentTool = {
     name: "list_content",
-    description: "List content items in your account. Content can be drafts, in review, published, or archived.",
+    description: "List content items in your account. Content can be drafts, in review, published, or archived. Use status 'archived' to list trashed/deleted content.",
     inputSchema: {
         type: "object",
         properties: {
@@ -70,8 +98,8 @@ export const listContentTool = {
             },
             status: {
                 type: "string",
-                enum: ["draft", "generating", "review", "published", "archived"],
-                description: "Filter by status",
+                enum: ["drafting", "review", "published", "archived"],
+                description: "Filter by status. Values match the Frase app: drafting (content being written), review (content under review), published (live content), archived (trashed/deleted items).",
             },
             site_id: {
                 type: "string",
@@ -90,17 +118,36 @@ export async function executeListContent(input, context) {
     }
     const { page, page_size, status, site_id } = parsed.data;
     try {
+        // Map display status to DB statuses for the API query
+        const dbStatuses = status ? CONTENT_STATUS_DISPLAY_TO_DB[status] : undefined;
+        // If the display status maps to a single DB status, pass it directly;
+        // otherwise fetch all and filter client-side
+        const singleDbStatus = dbStatuses?.length === 1 ? dbStatuses[0] : undefined;
         const params = { page, page_size };
-        if (status)
-            params.status = status;
+        if (singleDbStatus)
+            params.status = singleDbStatus;
         if (site_id)
             params.site_id = site_id;
-        const response = await context.client.get("/content", params, CACHE_TTL.lists);
+        // Use TTL 0 for archived content to ensure freshness after recent deletes
+        const cacheTtl = status === "archived" ? 0 : CACHE_TTL.lists;
+        const response = await context.client.get("/content", params, cacheTtl);
+        // Client-side filter when display status maps to multiple DB statuses
+        const filteredData = dbStatuses && !singleDbStatus
+            ? response.data.filter((c) => dbStatuses.includes(c.status))
+            : response.data;
+        // Map DB status → display label matching the Frase web app
+        const DB_STATUS_TO_LABEL = {
+            draft: "Drafting",
+            generating: "Drafting",
+            review: "In Review",
+            published: "Published",
+            archived: "Archived",
+        };
         const headers = ["ID", "Title", "Status", "Words", "Updated"];
-        const rows = response.data.map((c) => [
+        const rows = filteredData.map((c) => [
             c.id,
             truncate(c.title || "Untitled", 40),
-            formatStatus(c.status),
+            DB_STATUS_TO_LABEL[c.status] || formatStatus(c.status),
             formatWordCount(c.word_count),
             c.updated_at ? formatDate(c.updated_at) : formatDate(c.created_at),
         ]);
@@ -155,12 +202,21 @@ export async function executeGetContent(input, context) {
     }
     const { id, include_body } = parsed.data;
     try {
-        const response = await context.client.get(`/content/${id}`, undefined, CACHE_TTL.resources);
+        const response = await context.client.get(`/content/${id}`, undefined, 0 // Never cache content — body changes after regeneration/improvement
+        );
         const content = response.data;
+        // Map DB status → display label matching the Frase web app
+        const DETAIL_STATUS_LABEL = {
+            draft: "Drafting",
+            generating: "Drafting",
+            review: "In Review",
+            published: "Published",
+            archived: "Archived",
+        };
         let markdown = `## ${content.title || "Untitled Content"}\n\n`;
         markdown += formatKeyValue({
             ID: content.id,
-            Status: content.status,
+            Status: DETAIL_STATUS_LABEL[content.status] || content.status,
             "Word Count": content.word_count,
             Type: content.type,
             Slug: content.slug,
@@ -172,6 +228,34 @@ export async function executeGetContent(input, context) {
             Updated: content.updated_at ? formatDate(content.updated_at) : null,
             Published: content.published_at ? formatDate(content.published_at) : null,
         });
+        // E-E-A-T Breakdown
+        if (content.eeat_breakdown) {
+            const b = content.eeat_breakdown;
+            markdown += `\n\n### E-E-A-T Breakdown\n\n`;
+            markdown += `| Pillar | Score | Details |\n|--------|-------|--------|\n`;
+            const exp = b.experience;
+            const isV2Experience = exp?.firstPersonAction !== undefined;
+            if (isV2Experience) {
+                markdown += `| Experience | ${exp?.score ?? 0}/20 | Action: ${exp?.firstPersonAction ?? 0}/4, Specifics: ${exp?.specificity ?? 0}/4, Duration: ${exp?.temporalDepth ?? 0}/3, Artifacts: ${exp?.originalArtifacts ?? 0}/4, Outcomes: ${exp?.outcomeLanguage ?? 0}/3, Declaration: ${exp?.experienceDeclaration ?? 0}/2 |\n`;
+            }
+            else {
+                markdown += `| Experience | ${exp?.score ?? 0}/20 | First-person: ${exp?.firstPersonUsage ?? 0}/8, Media: ${exp?.originalMedia ?? 0}/6, Narrative: ${exp?.narrativeEvidence ?? 0}/6 |\n`;
+            }
+            markdown += `| Expertise | ${b.expertise?.score ?? 0}/20 | Author entity: ${b.expertise?.authorEntity ?? 0}/6, Bio quality: ${b.expertise?.bioQuality ?? 0}/8, Depth: ${b.expertise?.topicalDepth ?? 0}/6 |\n`;
+            markdown += `| Authority | ${b.authority?.score ?? 0}/20 | Expertise signals: ${b.authority?.expertiseSignals ?? 0}/8, Social proof: ${b.authority?.socialProof ?? 0}/12${b.authority?.brandMentions > 0 ? `, Brand mentions: ${b.authority.brandMentions}` : ""} |\n`;
+            markdown += `| Trust | ${b.trust?.score ?? 0}/40 | Source Authority: ${b.trust?.citationVelocity ?? 0}/12, Policies: ${b.trust?.policyTransparency ?? 0}/10, Freshness: ${b.trust?.freshness ?? 0}/10, Disclosure: ${b.trust?.conflictOfInterest ?? 0}/8 |\n`;
+            // Weight annotation for non-default content-type weights (PRO-2169 3E)
+            const w = b.appliedWeights;
+            const isDefault = !w || (w.trust === 47 && w.experience === 0 && w.expertise === 33 && w.authority === 20);
+            if (!isDefault && w) {
+                const label = getWeightLabel(b.appliedWeightProfile || "custom");
+                markdown += `| Applied Weights | | Trust ${w.trust ?? 0}% · Experience ${w.experience ?? 0}% · Expertise ${w.expertise ?? 0}% · Authority ${w.authority ?? 0}% |\n`;
+                markdown += `\n> Weights adjusted for ${label} content.\n`;
+            }
+            if (b.isYMYL) {
+                markdown += `\n> **YMYL content detected** — higher quality standards apply for this topic.\n`;
+            }
+        }
         // Meta tags
         if (content.meta_title || content.meta_description) {
             markdown += `\n\n### Meta Tags\n\n`;
@@ -182,10 +266,25 @@ export async function executeGetContent(input, context) {
                 markdown += `- **Description:** ${content.meta_description}\n`;
             }
         }
-        // Content body — convert HTML to readable text to prevent content loss
+        // PRO-1887: Surface improvement status so Claude knows whether an async improvement is done
+        if (content.progress_details?.improvingStatus) {
+            const status = content.progress_details.improvingStatus;
+            if (status === "in_progress") {
+                markdown += `\n\n> **Improvement status:** in_progress — An AI improvement is currently being applied. Wait 15-30 seconds and call \`get_content\` again.\n`;
+            }
+            else if (status === "completed") {
+                markdown += `\n\n> **Improvement status:** completed — The AI improvement was successfully applied.\n`;
+            }
+            else if (status === "failed") {
+                markdown += `\n\n> **Improvement status:** failed — The AI improvement failed. You may retry with \`regenerate_content\`.\n`;
+            }
+        }
+        // Content body — convert HTML to readable text; pass markdown through as-is (PRO-1866)
         if (include_body && content.body) {
             markdown += `\n\n### Content Body\n\n`;
-            const readableBody = htmlToReadableText(content.body);
+            const readableBody = isHtmlContent(content.body)
+                ? htmlToReadableText(content.body)
+                : content.body;
             // Truncate extremely long content (50K chars ≈ 8K+ words)
             if (readableBody.length > 50000) {
                 markdown += readableBody.slice(0, 50000);
@@ -244,6 +343,27 @@ export async function executeGenerateContent(input, context) {
     }
     const { brief_id, generate_images } = parsed.data;
     try {
+        // Check if the brief already has linked content (app hides Generate button in this case)
+        try {
+            const briefResponse = await context.client.get(`/briefs/${brief_id}`, undefined, 0);
+            if (briefResponse.data?.linked_content) {
+                const linked = briefResponse.data.linked_content;
+                return {
+                    success: false,
+                    markdown: `**Error:** This brief already has linked content.\n\n` +
+                        formatKeyValue({
+                            "Existing Content ID": linked.id,
+                            Title: linked.title || "Untitled",
+                            Status: formatStatus(linked.status),
+                        }) +
+                        `\n\nTo regenerate this content, use \`regenerate_content\` with \`content_id: "${linked.id}"\`.\n` +
+                        `To improve it with specific instructions, use \`regenerate_content\` with \`content_id: "${linked.id}"\` and \`instructions\`.`,
+                };
+            }
+        }
+        catch {
+            // Brief lookup failed — proceed with generation anyway (API will handle validation)
+        }
         const response = await context.client.post("/content/generate", { brief_id, generate_images });
         const content = response.data;
         let markdown = `## Content Generation Started\n\n`;
@@ -255,7 +375,7 @@ export async function executeGenerateContent(input, context) {
             "Generate Images": generate_images ? "Yes" : "No",
             Created: formatDate(content.created_at),
         });
-        markdown += `\n\n> **Tip:** Use \`get_job_status\` with the content ID to track generation progress.`;
+        markdown += `\n\n> **Tip:** Use \`get_content_status\` with the content ID to track generation progress (~2-5 minutes).`;
         return {
             success: true,
             markdown,
@@ -273,17 +393,23 @@ export async function executeGenerateContent(input, context) {
 // ============================================
 // update_content
 // ============================================
+// Map update_content display status → single DB status
+const UPDATE_STATUS_DISPLAY_TO_DB = {
+    drafting: "draft",
+    review: "review",
+    published: "published",
+};
 const updateContentInputSchema = z.object({
     id: z.string().min(1),
     title: z.string().optional(),
     body: z.string().optional(),
-    status: z.enum(["draft", "generating", "review", "published", "archived"]).optional(),
+    status: z.enum(["drafting", "review", "published"]).optional(),
     meta_title: z.string().optional(),
     meta_description: z.string().optional(),
 });
 export const updateContentTool = {
     name: "update_content",
-    description: "Update a content item's title, body, status, or meta tags.",
+    description: "Update a content item's title, body, status, or meta tags. To archive/trash content, use delete_content instead.",
     inputSchema: {
         type: "object",
         properties: {
@@ -301,8 +427,8 @@ export const updateContentTool = {
             },
             status: {
                 type: "string",
-                enum: ["draft", "generating", "review", "published", "archived"],
-                description: "New status",
+                enum: ["drafting", "review", "published"],
+                description: "New status. Values match the Frase app: drafting (move to drafts), review (send for review), published (mark as published). To archive/trash content, use delete_content instead.",
             },
             meta_title: {
                 type: "string",
@@ -324,9 +450,11 @@ export async function executeUpdateContent(input, context) {
             markdown: `**Error:** Invalid input - ${parsed.error.message}`,
         };
     }
-    const { id, ...updates } = parsed.data;
-    // Filter out undefined values
-    const fieldsToUpdate = Object.fromEntries(Object.entries(updates).filter(([, v]) => v !== undefined));
+    const { id, status: displayStatus, ...otherUpdates } = parsed.data;
+    // Map display status to DB status
+    const dbStatus = displayStatus ? UPDATE_STATUS_DISPLAY_TO_DB[displayStatus] : undefined;
+    // Filter out undefined values and include mapped DB status
+    const fieldsToUpdate = Object.fromEntries(Object.entries({ ...otherUpdates, status: dbStatus }).filter(([, v]) => v !== undefined));
     if (Object.keys(fieldsToUpdate).length === 0) {
         return {
             success: false,
@@ -398,7 +526,7 @@ export async function executeDeleteContent(input, context) {
         await context.client.delete(`/content/${id}`);
         return {
             success: true,
-            markdown: `## Content Deleted\n\nContent \`${id}\` has been moved to trash.`,
+            markdown: `## Content Deleted\n\nContent \`${id}\` has been moved to trash.\n\n> **Tip:** To view trashed items, use \`list_content\` with \`status: "archived"\`.`,
         };
     }
     catch (error) {
@@ -439,7 +567,8 @@ export async function executeGetContentStatus(input, context) {
     }
     const { id } = parsed.data;
     try {
-        const response = await context.client.get(`/content/${id}/status`, undefined, CACHE_TTL.resources);
+        const response = await context.client.get(`/content/${id}/status`, undefined, 0 // Never cache status — this is a polling endpoint (app polls fresh every 2s)
+        );
         const status = response.data;
         let markdown = `## Content Status\n\n`;
         markdown += formatKeyValue({
@@ -558,7 +687,7 @@ const regenerateContentInputSchema = z.object({
 });
 export const regenerateContentTool = {
     name: "regenerate_content",
-    description: "Regenerate or improve existing content. Without instructions, the content is fully regenerated from its brief. With instructions, the content is rewritten using AI following those instructions. Both operations run asynchronously — use get_content_status to track progress. Note: AI improvements may change the word count; include 'maintain the current word count' in instructions if length preservation is important.",
+    description: "Regenerate or improve existing content. This is an async operation. Without instructions, fully regenerates from brief (~2-5 min; poll get_content_status until status changes from 'generating' to 'review'). With instructions, rewrites using AI (~30-60 sec). After calling this tool with instructions, wait 30 seconds then use get_content to check: look for improvingStatus ('completed' = done, 'in_progress' = wait and retry, 'failed' = error) or compare the updatedAt timestamp. Note: AI improvements may change the word count; include 'maintain the current word count' in instructions if length preservation is important.",
     inputSchema: {
         type: "object",
         properties: {
@@ -601,11 +730,15 @@ export async function executeRegenerateContent(input, context) {
             Status: formatStatus(result.status),
             "Brief ID": result.brief_id,
             Method: instructions ? "AI Improvement" : "Full Regeneration",
+            "Current updatedAt": result.updated_at || "unknown",
         });
         if (instructions) {
             markdown += `\n\n**Instructions:** ${instructions.length > 200 ? instructions.slice(0, 200) + "..." : instructions}`;
+            markdown += `\n\n> **Important:** AI improvement is an async background operation (~30-60 seconds). Wait 30 seconds, then call \`get_content\` to check the result. Look for **improvingStatus** in the response: \`completed\` means the improvement was applied, \`in_progress\` means it is still running (wait and retry), \`failed\` means it errored. You can also compare the \`updatedAt\` timestamp — if it changed from \`${result.updated_at || "the value above"}\`, the content was updated.`;
+        }
+        else {
+            markdown += `\n\n> **Important:** Full regeneration is an async operation (~2-5 minutes). Use \`get_content_status\` to poll until status changes from "generating" to "review", then use \`get_content\` to read the new body text.`;
         }
-        markdown += `\n\n> **Tip:** Use \`get_content_status\` with the content ID to track regeneration progress.`;
         return {
             success: true,
             markdown,
@@ -655,10 +788,18 @@ export async function executeRescoreContent(input, context) {
         let markdown = `## Content Rescored\n\n`;
         // Score summary table
         const headers = ["Score Type", "Score", "Rating"];
+        // Check for non-default EEAT weights (PRO-2169 3E)
+        const eeatBd = result.scores.eeat_breakdown;
+        const aw = eeatBd?.appliedWeights;
+        const isDefaultWeights = !aw || (aw.trust === 47 && aw.experience === 0 && aw.expertise === 33 && aw.authority === 20);
+        const weightLabel = !isDefaultWeights
+            ? getWeightLabel(eeatBd?.appliedWeightProfile || "custom")
+            : null;
+        const eeatRating = getScoreRating(result.scores.eeat_score) + (weightLabel ? ` (weighted for ${weightLabel})` : "");
         const rows = [
             ["SEO", String(result.scores.seo_score), getScoreRating(result.scores.seo_score)],
             ["GEO", String(result.scores.geo_score), getScoreRating(result.scores.geo_score)],
-            ["EEAT", String(result.scores.eeat_score), getScoreRating(result.scores.eeat_score)],
+            ["EEAT", String(result.scores.eeat_score), eeatRating],
         ];
         markdown += formatTable(headers, rows);
         markdown += `\n\n`;
@@ -681,6 +822,14 @@ export async function executeRescoreContent(input, context) {
         };
     }
 }
+/** Convert weight profile key to human-readable label (shared by get_content + rescore_content) */
+function getWeightLabel(profile) {
+    if (profile.startsWith("blog:"))
+        return profile.split(":")[1];
+    if (profile === "landing" || profile === "product")
+        return `${profile} page`;
+    return profile;
+}
 function getScoreRating(score) {
     if (score >= 80)
         return "Excellent";
@@ -693,14 +842,183 @@ function getScoreRating(score) {
     return "Not Competitive";
 }
 // ============================================
+// get_content_summary
+// ============================================
+export const getContentSummaryTool = {
+    name: "get_content_summary",
+    description: "Get a summary of content counts grouped by status. Returns accurate totals for draft, generating, review, published, and archived content. Use this instead of list_content when you need an overview of how much content exists per status.",
+    inputSchema: {
+        type: "object",
+        properties: {},
+    },
+};
+export async function executeGetContentSummary(_input, context) {
+    try {
+        const response = await context.client.get("/content/summary", undefined, CACHE_TTL.lists);
+        const { status_counts, total } = response.data;
+        // Build LLM-friendly text output
+        let markdown = `## Content Summary\n\n`;
+        markdown += `**Total:** ${total} content item${total === 1 ? "" : "s"}\n\n`;
+        if (status_counts.length === 0) {
+            markdown += `No content items found.\n`;
+        }
+        else {
+            // Sort by count descending for readability
+            const sorted = [...status_counts].sort((a, b) => b.count - a.count);
+            for (const { status, count } of sorted) {
+                markdown += `- **${formatStatus(status)}:** ${count}\n`;
+            }
+        }
+        return {
+            success: true,
+            markdown,
+            data: response,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+            success: false,
+            markdown: `**Error:** Failed to get content summary - ${message}`,
+        };
+    }
+}
+// ============================================
+// restore_content
+// ============================================
+const restoreContentInputSchema = z.object({
+    id: z.string().min(1),
+});
+export const restoreContentTool = {
+    name: "restore_content",
+    description: "Restore a trashed (soft-deleted) content item. Content can be restored within 30 days of deletion. Use list_content with status 'archived' to find trashed items.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            id: {
+                type: "string",
+                description: "The content ID to restore (required)",
+            },
+        },
+        required: ["id"],
+    },
+};
+export async function executeRestoreContent(input, context) {
+    const parsed = restoreContentInputSchema.safeParse(input);
+    if (!parsed.success) {
+        return {
+            success: false,
+            markdown: `**Error:** Invalid input - ${parsed.error.message}`,
+        };
+    }
+    const { id } = parsed.data;
+    try {
+        const response = await context.client.post(`/content/${id}/restore`, {});
+        const content = response.data;
+        return {
+            success: true,
+            markdown: `## Content Restored\n\n${formatKeyValue({
+                ID: content.id,
+                Title: content.title,
+                Status: formatStatus(content.status),
+            })}\n\nThe content has been restored from trash and is available again.`,
+            data: response,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+            success: false,
+            markdown: `**Error:** Failed to restore content - ${message}`,
+        };
+    }
+}
+// ============================================
+// list_trash
+// ============================================
+const listTrashInputSchema = z.object({
+    limit: z.number().min(1).max(100).optional().default(20),
+    offset: z.number().min(0).optional().default(0),
+    site_id: z.string().optional(),
+});
+export const listTrashTool = {
+    name: "list_trash",
+    description: "List trashed/deleted content items. Returns content that has been soft-deleted (moved to trash).",
+    inputSchema: {
+        type: "object",
+        properties: {
+            limit: {
+                type: "number",
+                description: "Max items to return, max 100 (default: 20)",
+            },
+            offset: {
+                type: "number",
+                description: "Number of items to skip for pagination (default: 0)",
+            },
+            site_id: {
+                type: "string",
+                description: "Filter by site ID. Use list_sites to get available site IDs.",
+            },
+        },
+    },
+};
+export async function executeListTrash(input, context) {
+    const parsed = listTrashInputSchema.safeParse(input || {});
+    if (!parsed.success) {
+        return {
+            success: false,
+            markdown: `**Error:** Invalid input - ${parsed.error.message}`,
+        };
+    }
+    const { limit, offset, site_id } = parsed.data;
+    // Convert limit/offset to page/page_size for the API
+    const page = Math.floor(offset / limit) + 1;
+    try {
+        const params = {
+            page,
+            page_size: limit,
+            status: "archived",
+        };
+        if (site_id)
+            params.site_id = site_id;
+        const response = await context.client.get("/content", params, 0 // No cache — ensure freshness after recent deletes/restores
+        );
+        const headers = ["ID", "Title", "Status", "Words", "Updated"];
+        const rows = response.data.map((c) => [
+            c.id,
+            truncate(c.title || "Untitled", 40),
+            formatStatus(c.status),
+            formatWordCount(c.word_count),
+            c.updated_at ? formatDate(c.updated_at) : formatDate(c.created_at),
+        ]);
+        const table = formatTable(headers, rows);
+        const pagination = formatPagination(response.pagination);
+        return {
+            success: true,
+            markdown: `## Trash (Page ${page})\n\n${table}${pagination}\n\n> **Tip:** Use \`restore_content\` with a content ID to recover an item from trash.`,
+            data: response,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+            success: false,
+            markdown: `**Error:** Failed to list trashed content - ${message}`,
+        };
+    }
+}
+// ============================================
 // Export all content tools
 // ============================================
 export const contentTools = [
     listContentTool,
+    listTrashTool,
     getContentTool,
+    getContentSummaryTool,
     generateContentTool,
     updateContentTool,
     deleteContentTool,
+    restoreContentTool,
     getContentStatusTool,
     exportContentTool,
     regenerateContentTool,
@@ -708,10 +1026,13 @@ export const contentTools = [
 ];
 export const contentExecutors = {
     list_content: executeListContent,
+    list_trash: executeListTrash,
     get_content: executeGetContent,
+    get_content_summary: executeGetContentSummary,
     generate_content: executeGenerateContent,
     update_content: executeUpdateContent,
     delete_content: executeDeleteContent,
+    restore_content: executeRestoreContent,
     get_content_status: executeGetContentStatus,
     export_content: executeExportContent,
     regenerate_content: executeRegenerateContent,