diff --git a/__tests__/unit/writing-parse.test.ts b/__tests__/unit/writing-parse.test.ts
new file mode 100644
index 000000000..03eca702d
--- /dev/null
+++ b/__tests__/unit/writing-parse.test.ts
@@ -0,0 +1,30 @@
+/**
+ * parseJsonLoose — the defensive parser between raw model output and the writing
+ * engine. Model JSON is unpredictable (code fences, leading prose), so this must
+ * be forgiving without ever throwing.
+ */
+import { parseJsonLoose } from '@/services/cat/platform-llm';
+
+describe('parseJsonLoose', () => {
+  it('parses clean JSON objects and arrays', () => {
+    expect(parseJsonLoose('{"a":1}')).toEqual({ a: 1 });
+    expect(parseJsonLoose('[1,2,3]')).toEqual([1, 2, 3]);
+  });
+
+  it('strips ```json fences', () => {
+    expect(parseJsonLoose('```json\n{"topics":[]}\n```')).toEqual({ topics: [] });
+    expect(parseJsonLoose('```\n{"x":true}\n```')).toEqual({ x: true });
+  });
+
+  it('recovers JSON embedded in prose', () => {
+    const raw = 'Sure! Here are your topics: {"topics":[{"title":"Hi"}]} Hope that helps.';
+    expect(parseJsonLoose<{ topics: unknown[] }>(raw)?.topics).toHaveLength(1);
+  });
+
+  it('returns null (never throws) on unparseable or empty input', () => {
+    expect(parseJsonLoose(null)).toBeNull();
+    expect(parseJsonLoose('')).toBeNull();
+    expect(parseJsonLoose('not json at all')).toBeNull();
+    expect(parseJsonLoose('{ broken ')).toBeNull();
+  });
+});
diff --git a/src/app/(public)/articles/[slug]/ReadingProgress.tsx b/src/app/(public)/articles/[slug]/ReadingProgress.tsx
new file mode 100644
index 000000000..4fde383f3
--- /dev/null
+++ b/src/app/(public)/articles/[slug]/ReadingProgress.tsx
@@ -0,0 +1,45 @@
+'use client';
+
+import { useEffect, useState } from 'react';
+
+/**
+ * A thin top-of-page reading-progress bar. Tasteful, not gamified — a single
+ * accent hairline that tracks scroll depth, the standard long-form affordance.
+ */
+export default function ReadingProgress() {
+  const [progress, setProgress] = useState(0);
+
+  useEffect(() => {
+    let frame = 0;
+    const update = () => {
+      frame = 0;
+      const doc = document.documentElement;
+      const scrollable = doc.scrollHeight - doc.clientHeight;
+      setProgress(scrollable > 0 ? Math.min(1, doc.scrollTop / scrollable) : 0);
+    };
+    const onScroll = () => {
+      if (!frame) {
+        frame = requestAnimationFrame(update);
+      }
+    };
+    update();
+    window.addEventListener('scroll', onScroll, { passive: true });
+    window.addEventListener('resize', onScroll);
+    return () => {
+      window.removeEventListener('scroll', onScroll);
+      window.removeEventListener('resize', onScroll);
+      if (frame) {
+        cancelAnimationFrame(frame);
+      }
+    };
+  }, []);
+
+  return (
+    <div className="fixed inset-x-0 top-0 z-50 h-0.5 bg-transparent" aria-hidden>
+      <div
+        className="h-full bg-accent-warm transition-[width] duration-150 ease-out"
+        style={{ width: `${progress * 100}%` }}
+      />
+    </div>
+  );
+}
diff --git a/src/app/(public)/articles/[slug]/ShareButton.tsx b/src/app/(public)/articles/[slug]/ShareButton.tsx
new file mode 100644
index 000000000..33fbc7a0a
--- /dev/null
+++ b/src/app/(public)/articles/[slug]/ShareButton.tsx
@@ -0,0 +1,41 @@
+'use client';
+
+import { useState } from 'react';
+import { Check, Share2 } from 'lucide-react';
+
+/**
+ * Share affordance for an article — native share sheet where available, else
+ * copy-to-clipboard with a brief confirmation. No third-party share widgets.
+ */
+export default function ShareButton({ title, url }: { title: string; url: string }) {
+  const [copied, setCopied] = useState(false);
+
+  async function share() {
+    if (typeof navigator !== 'undefined' && navigator.share) {
+      try {
+        await navigator.share({ title, url });
+        return;
+      } catch {
+        /* user dismissed — fall through to copy */
+      }
+    }
+    try {
+      await navigator.clipboard.writeText(url);
+      setCopied(true);
+      setTimeout(() => setCopied(false), 2000);
+    } catch {
+      /* clipboard blocked — no-op */
+    }
+  }
+
+  return (
+    <button
+      type="button"
+      onClick={share}
+      className="inline-flex items-center gap-1.5 rounded-md border border-default px-3 py-1.5 text-sm font-medium text-fg-secondary transition-colors hover:bg-surface-raised hover:text-fg-primary"
+    >
+      {copied ? <Check className="h-4 w-4 text-status-positive" /> : <Share2 className="h-4 w-4" />}
+      {copied ? 'Link copied' : 'Share'}
+    </button>
+  );
+}
diff --git a/src/app/(public)/articles/[slug]/page.tsx b/src/app/(public)/articles/[slug]/page.tsx
index 5351b2309..ef0e75272 100644
--- a/src/app/(public)/articles/[slug]/page.tsx
+++ b/src/app/(public)/articles/[slug]/page.tsx
@@ -8,6 +8,8 @@ import { ROUTES } from '@/config/routes';
 import { JsonLdScript } from '@/lib/seo/structured-data';
 import { APP_NAME, SITE_URL } from '@/config/brand';
 import ArticleMarkdown from './ArticleMarkdown';
+import ReadingProgress from './ReadingProgress';
+import ShareButton from './ShareButton';
 
 interface PageProps {
   params: Promise<{ slug: string }>;
@@ -75,10 +77,12 @@ export default async function ArticlePage({ params }: PageProps) {
   };
 
   const authorHref = profileHref(article.author.username, article.author.id);
+  const shareUrl = `${SITE_URL}/articles/${article.slug}`;
 
   return (
     <>
       {article.visibility === 'public' && <JsonLdScript data={jsonLd} />}
+      <ReadingProgress />
       <div className="min-h-screen bg-surface-page pt-20 pb-24 text-fg-primary">
         <article className="mx-auto w-full max-w-[680px] px-5">
           <Link
@@ -151,6 +155,46 @@ export default async function ArticlePage({ params }: PageProps) {
           <div className="[&>*:first-child]:mt-0">
             <ArticleMarkdown body={article.body} />
           </div>
+
+          {/* Footer: author card + share + write-your-own CTA */}
+          <footer className="mt-14 border-t border-subtle pt-8">
+            <div className="flex flex-wrap items-center justify-between gap-4">
+              <Link
+                href={authorHref}
+                className="flex items-center gap-3 transition-opacity hover:opacity-80"
+              >
+                {article.author.avatarUrl ? (
+                  // eslint-disable-next-line @next/next/no-img-element
+                  <img
+                    src={article.author.avatarUrl}
+                    alt=""
+                    className="h-11 w-11 rounded-full border border-subtle object-cover"
+                  />
+                ) : (
+                  <span className="flex h-11 w-11 items-center justify-center rounded-full border border-subtle bg-surface-raised text-sm font-semibold text-fg-secondary">
+                    {article.author.name.slice(0, 1).toUpperCase()}
+                  </span>
+                )}
+                <span>
+                  <span className="block text-xs text-fg-tertiary">Written by</span>
+                  <span className="block font-semibold text-fg-primary">{article.author.name}</span>
+                </span>
+              </Link>
+              <ShareButton title={article.title} url={shareUrl} />
+            </div>
+
+            <div className="mt-8 flex flex-col items-start gap-3 rounded-xl border border-subtle bg-surface-raised/25 px-5 py-5 sm:flex-row sm:items-center sm:justify-between">
+              <p className="text-sm text-fg-secondary">
+                Have something to say? Publishing on OrangeCat is free.
+              </p>
+              <Link
+                href={ROUTES.ARTICLES_NEW}
+                className="inline-flex flex-shrink-0 items-center gap-1.5 rounded-md bg-accent-warm px-3.5 py-2 text-sm font-semibold text-white transition-colors hover:bg-accent-warm-hover"
+              >
+                Write your own
+              </Link>
+            </div>
+          </footer>
         </article>
       </div>
     </>
diff --git a/src/app/(public)/articles/new/ArticleComposer.tsx b/src/app/(public)/articles/new/ArticleComposer.tsx
index eaa5159c9..c9850fbe5 100644
--- a/src/app/(public)/articles/new/ArticleComposer.tsx
+++ b/src/app/(public)/articles/new/ArticleComposer.tsx
@@ -1,6 +1,6 @@
 'use client';
 
-import { useState } from 'react';
+import { useEffect, useRef, useState } from 'react';
 import { useRouter } from 'next/navigation';
 import Link from 'next/link';
 import { ArrowLeft, Eye, PenLine } from 'lucide-react';
@@ -13,7 +13,21 @@ import { ARTICLE_COPY, ARTICLE_LIMITS, estimateReadingTime } from '@/config/arti
 import { ROUTES } from '@/config/routes';
 import { publishArticle } from '@/services/articles/create';
 import type { TimelineVisibility } from '@/types/timeline';
+import type { ArticleDraft } from '@/services/cat/writing-types';
 import ArticleMarkdown from '../[slug]/ArticleMarkdown';
+import MarkdownToolbar from '@/components/articles/MarkdownToolbar';
+import { useMarkdownTextarea } from '@/components/articles/useMarkdownTextarea';
+import AiWriterPanel from '@/components/articles/AiWriterPanel';
+
+const DRAFT_KEY = 'oc:draft:article';
+
+interface DraftShape {
+  title: string;
+  excerpt: string;
+  coverImage: string;
+  body: string;
+  visibility: TimelineVisibility;
+}
 
 export default function ArticleComposer({ user }: { user: { id: string } }) {
   const router = useRouter();
@@ -25,9 +39,82 @@ export default function ArticleComposer({ user }: { user: { id: string } }) {
   const [tab, setTab] = useState<'write' | 'preview'>('write');
   const [publishing, setPublishing] = useState(false);
   const [error, setError] = useState<string | null>(null);
+  const [restored, setRestored] = useState(false);
+
+  const bodyRef = useRef<HTMLTextAreaElement>(null);
+  const md = useMarkdownTextarea(bodyRef, body, setBody);
+
+  // Restore an in-progress draft once on mount.
+  useEffect(() => {
+    try {
+      const raw = localStorage.getItem(DRAFT_KEY);
+      if (!raw) {
+        return;
+      }
+      const d = JSON.parse(raw) as Partial<DraftShape>;
+      if (d.title || d.body) {
+        setTitle(d.title ?? '');
+        setExcerpt(d.excerpt ?? '');
+        setCoverImage(d.coverImage ?? '');
+        setBody(d.body ?? '');
+        if (d.visibility) {
+          setVisibility(d.visibility);
+        }
+        setRestored(true);
+      }
+    } catch {
+      /* ignore corrupt draft */
+    }
+  }, []);
+
+  // Autosave (debounced) whenever content changes.
+  useEffect(() => {
+    if (!title && !body && !excerpt && !coverImage) {
+      return;
+    }
+    const id = setTimeout(() => {
+      try {
+        localStorage.setItem(
+          DRAFT_KEY,
+          JSON.stringify({ title, excerpt, coverImage, body, visibility } satisfies DraftShape)
+        );
+      } catch {
+        /* storage full / disabled — non-fatal */
+      }
+    }, 600);
+    return () => clearTimeout(id);
+  }, [title, excerpt, coverImage, body, visibility]);
 
+  const wordCount = body.trim() ? body.trim().split(/\s+/).length : 0;
+  const readingTime = wordCount ? estimateReadingTime(body) : 0;
   const canPublish = title.trim().length > 0 && body.trim().length > 0 && !publishing;
-  const readingTime = body.trim() ? estimateReadingTime(body) : 0;
+
+  function applyDraft(draft: ArticleDraft) {
+    setTitle(draft.title);
+    if (draft.excerpt) {
+      setExcerpt(draft.excerpt);
+    }
+    setBody(draft.body);
+    setTab('write');
+    setRestored(false);
+  }
+
+  function handleBodyKeyDown(e: React.KeyboardEvent<HTMLTextAreaElement>) {
+    if (!(e.metaKey || e.ctrlKey)) {
+      return;
+    }
+    const k = e.key.toLowerCase();
+    if (k === 'b') {
+      e.preventDefault();
+      md.wrap('**', '**', 'bold');
+    } else if (k === 'i') {
+      e.preventDefault();
+      md.wrap('*', '*', 'italic');
+    } else if (k === 'k') {
+      e.preventDefault();
+      md.insertLink();
+    }
+  }
 
   async function handlePublish() {
     if (!canPublish) {
@@ -47,6 +134,11 @@ export default function ArticleComposer({ user }: { user: { id: string } }) {
       setPublishing(false);
       return;
     }
+    try {
+      localStorage.removeItem(DRAFT_KEY);
+    } catch {
+      /* ignore */
+    }
     router.push(ROUTES.ARTICLE(result.slug));
   }
 
@@ -61,15 +153,25 @@ export default function ArticleComposer({ user }: { user: { id: string } }) {
           {ARTICLE_COPY.reader.back}
         </Link>
 
-        <header className="mb-6">
+        <header className="mb-5">
           <h1 className="text-2xl font-semibold tracking-display text-fg-primary">
             {ARTICLE_COPY.new.heading}
           </h1>
           <p className="mt-1.5 text-sm text-fg-secondary">{ARTICLE_COPY.new.subheading}</p>
         </header>
 
+        <div className="mb-5">
+          <AiWriterPanel title={title} onApplyDraft={applyDraft} disabled={publishing} />
+        </div>
+
+        {restored && (
+          <p className="mb-4 rounded-md border border-subtle bg-surface-raised/30 px-3 py-2 text-xs text-fg-secondary">
+            Restored your saved draft.
+          </p>
+        )}
+
         {/* Write / Preview tabs */}
-        <div className="mb-4 flex items-center gap-2">
+        <div className="mb-3 flex items-center gap-2">
           <button
             type="button"
             onClick={() => setTab('write')}
@@ -84,8 +186,11 @@ export default function ArticleComposer({ user }: { user: { id: string } }) {
           >
             <Eye className="h-4 w-4" /> Preview
           </button>
-          {readingTime > 0 && (
-            <span className="ml-auto text-xs text-fg-tertiary">{readingTime} min read</span>
+          {wordCount > 0 && (
+            <span className="ml-auto text-xs text-fg-tertiary">
+              {wordCount.toLocaleString()} {wordCount === 1 ? 'word' : 'words'} · {readingTime} min
+              read
+            </span>
           )}
         </div>
 
@@ -114,15 +219,20 @@ export default function ArticleComposer({ user }: { user: { id: string } }) {
               type="url"
               aria-label="Cover image URL"
             />
-            <Textarea
-              value={body}
-              onChange={e => setBody(e.target.value)}
-              placeholder={ARTICLE_COPY.new.bodyPlaceholder}
-              rows={18}
-              maxLength={ARTICLE_LIMITS.body}
-              aria-label="Article body"
-              className="font-mono text-sm leading-6"
-            />
+            <div>
+              <MarkdownToolbar actions={md} disabled={publishing} />
+              <Textarea
+                ref={bodyRef}
+                value={body}
+                onChange={e => setBody(e.target.value)}
+                onKeyDown={handleBodyKeyDown}
+                placeholder={ARTICLE_COPY.new.bodyPlaceholder}
+                rows={18}
+                maxLength={ARTICLE_LIMITS.body}
+                aria-label="Article body"
+                className="rounded-t-none font-mono text-sm leading-6"
+              />
+            </div>
           </div>
         ) : (
           <div className="rounded-lg border border-subtle bg-surface-page p-6">
diff --git a/src/app/api/ai/writing/draft/route.ts b/src/app/api/ai/writing/draft/route.ts
new file mode 100644
index 000000000..e7e7eef7a
--- /dev/null
+++ b/src/app/api/ai/writing/draft/route.ts
@@ -0,0 +1,52 @@
+/**
+ * POST /api/ai/writing/draft — AI draft of a post or a full article, in the
+ * user's voice and grounded in their context. Thin wrapper over the
+ * writing-engine; auth + write-tier rate limit.
+ */
+
+import type { NextRequest, NextResponse } from 'next/server';
+import { z } from 'zod';
+import { withAuth, type AuthenticatedRequest } from '@/lib/api/withAuth';
+import { createRateLimitResponse, rateLimitWriteAsync } from '@/lib/rate-limit';
+import { apiBadRequest, apiError, apiInternalError, apiSuccess } from '@/lib/api/standardResponse';
+import { draftArticle, draftPost } from '@/services/cat/writing-engine';
+import { logger } from '@/utils/logger';
+
+const bodySchema = z.object({
+  mode: z.enum(['post', 'article']),
+  topic: z.string().trim().max(300).optional(),
+  focus: z.string().trim().max(200).optional(),
+});
+
+export const POST = withAuth(async (request: AuthenticatedRequest) => {
+  const { user, supabase } = request;
+  try {
+    const rl = await rateLimitWriteAsync(user.id);
+    if (!rl.success) {
+      return createRateLimitResponse(rl) as NextResponse;
+    }
+
+    const parsed = bodySchema.safeParse(await (request as NextRequest).json().catch(() => ({})));
+    if (!parsed.success) {
+      return apiBadRequest('Invalid request', parsed.error.flatten());
+    }
+
+    const { mode, topic, focus } = parsed.data;
+    const draft =
+      mode === 'article'
+        ? await draftArticle(supabase, user.id, { topic, focus })
+        : await draftPost(supabase, user.id, { topic, focus });
+
+    if (!draft) {
+      return apiError(
+        'The AI writer is busy right now. Try again in a moment, or add your own free Groq key in Settings → AI.',
+        'AI_UNAVAILABLE',
+        503
+      ) as NextResponse;
+    }
+    return apiSuccess({ mode, draft }) as NextResponse;
+  } catch (error) {
+    logger.error('writing/draft failed', error, 'WritingAPI');
+    return apiInternalError('Could not draft that right now. Please try again.');
+  }
+});
diff --git a/src/app/api/ai/writing/topics/route.ts b/src/app/api/ai/writing/topics/route.ts
new file mode 100644
index 000000000..36db495b9
--- /dev/null
+++ b/src/app/api/ai/writing/topics/route.ts
@@ -0,0 +1,40 @@
+/**
+ * POST /api/ai/writing/topics — AI-suggested writing topics grounded in the
+ * user's own context (profile, entities, memories, past posts). Thin wrapper
+ * over the writing-engine; auth + write-tier rate limit.
+ */
+
+import type { NextRequest, NextResponse } from 'next/server';
+import { z } from 'zod';
+import { withAuth, type AuthenticatedRequest } from '@/lib/api/withAuth';
+import { createRateLimitResponse, rateLimitWriteAsync } from '@/lib/rate-limit';
+import { apiBadRequest, apiInternalError, apiSuccess } from '@/lib/api/standardResponse';
+import { suggestTopics } from '@/services/cat/writing-engine';
+import { logger } from '@/utils/logger';
+
+const bodySchema = z.object({
+  count: z.number().int().min(1).max(8).optional(),
+  kind: z.enum(['post', 'article', 'any']).optional(),
+  focus: z.string().trim().max(200).optional(),
+});
+
+export const POST = withAuth(async (request: AuthenticatedRequest) => {
+  const { user, supabase } = request;
+  try {
+    const rl = await rateLimitWriteAsync(user.id);
+    if (!rl.success) {
+      return createRateLimitResponse(rl) as NextResponse;
+    }
+
+    const parsed = bodySchema.safeParse(await (request as NextRequest).json().catch(() => ({})));
+    if (!parsed.success) {
+      return apiBadRequest('Invalid request', parsed.error.flatten());
+    }
+
+    const topics = await suggestTopics(supabase, user.id, parsed.data);
+    return apiSuccess({ topics }) as NextResponse;
+  } catch (error) {
+    logger.error('writing/topics failed', error, 'WritingAPI');
+    return apiInternalError('Could not suggest topics right now. Please try again.');
+  }
+});
diff --git a/src/components/articles/AiWriterPanel.tsx b/src/components/articles/AiWriterPanel.tsx
new file mode 100644
index 000000000..83f4c1760
--- /dev/null
+++ b/src/components/articles/AiWriterPanel.tsx
@@ -0,0 +1,132 @@
+'use client';
+
+import { useState } from 'react';
+import { Sparkles, Loader2, PenLine, Lightbulb, ArrowRight } from 'lucide-react';
+import { cn } from '@/lib/utils';
+import { fetchArticleDraft, fetchWritingTopics } from '@/services/articles/ai-client';
+import type { ArticleDraft, ProposedTopic } from '@/services/cat/writing-types';
+
+/**
+ * One-click AI writing for the article composer. "Write a full draft" fills the
+ * whole editor; "Suggest topics" grounds ideas in the user's own interests and
+ * drafts the one they pick. Fails soft — errors surface inline, never block.
+ */
+export default function AiWriterPanel({
+  title,
+  onApplyDraft,
+  disabled,
+}: {
+  title: string;
+  onApplyDraft: (draft: ArticleDraft) => void;
+  disabled?: boolean;
+}) {
+  const [busy, setBusy] = useState<null | 'draft' | 'topics' | string>(null);
+  const [topics, setTopics] = useState<ProposedTopic[]>([]);
+  const [error, setError] = useState<string | null>(null);
+
+  const anyBusy = busy !== null || disabled;
+
+  async function writeDraft(topic?: string) {
+    setBusy(topic ?? 'draft');
+    setError(null);
+    try {
+      const draft = await fetchArticleDraft({ topic: topic || title.trim() || undefined });
+      onApplyDraft(draft);
+      setTopics([]);
+    } catch (e) {
+      setError(e instanceof Error ? e.message : 'Could not draft that. Please try again.');
+    } finally {
+      setBusy(null);
+    }
+  }
+
+  async function loadTopics() {
+    setBusy('topics');
+    setError(null);
+    try {
+      setTopics(await fetchWritingTopics({ kind: 'article', count: 5 }));
+    } catch (e) {
+      setError(e instanceof Error ? e.message : 'Could not suggest topics. Please try again.');
+    } finally {
+      setBusy(null);
+    }
+  }
+
+  return (
+    <div className="rounded-lg border border-subtle bg-surface-raised/25 p-4">
+      <div className="flex items-start gap-3">
+        <span className="mt-0.5 flex h-8 w-8 flex-shrink-0 items-center justify-center rounded-md bg-accent-warm/10 text-accent-warm">
+          <Sparkles className="h-4 w-4" />
+        </span>
+        <div className="min-w-0 flex-1">
+          <p className="text-sm font-semibold text-fg-primary">Write with AI</p>
+          <p className="text-xs text-fg-secondary">
+            Grounded in what you care about and what you've written before.
+          </p>
+
+          <div className="mt-3 flex flex-wrap gap-2">
+            <button
+              type="button"
+              disabled={anyBusy}
+              onClick={() => writeDraft()}
+              className="inline-flex items-center gap-1.5 rounded-md bg-accent-warm px-3 py-1.5 text-sm font-semibold text-white transition-colors hover:bg-accent-warm-hover disabled:opacity-50"
+            >
+              {busy === 'draft' ? (
+                <Loader2 className="h-4 w-4 animate-spin" />
+              ) : (
+                <PenLine className="h-4 w-4" />
+              )}
+              {title.trim() ? 'Write a full draft' : 'Write me a draft'}
+            </button>
+            <button
+              type="button"
+              disabled={anyBusy}
+              onClick={loadTopics}
+              className="inline-flex items-center gap-1.5 rounded-md border border-default px-3 py-1.5 text-sm font-medium text-fg-primary transition-colors hover:bg-surface-raised disabled:opacity-50"
+            >
+              {busy === 'topics' ? (
+                <Loader2 className="h-4 w-4 animate-spin" />
+              ) : (
+                <Lightbulb className="h-4 w-4" />
+              )}
+              Suggest topics
+            </button>
+          </div>
+
+          {topics.length > 0 && (
+            <ul className="mt-3 space-y-1.5">
+              {topics.map((t, i) => (
+                <li key={i}>
+                  <button
+                    type="button"
+                    disabled={anyBusy}
+                    onClick={() => writeDraft(t.title)}
+                    className={cn(
+                      'group flex w-full items-center gap-2 rounded-md border border-subtle bg-surface-page px-3 py-2 text-left transition-colors hover:border-default disabled:opacity-50'
+                    )}
+                  >
+                    <span className="min-w-0 flex-1">
+                      <span className="block truncate text-sm font-medium text-fg-primary">
+                        {t.title}
+                      </span>
+                      {t.angle && (
+                        <span className="block truncate text-xs text-fg-secondary">{t.angle}</span>
+                      )}
+                    </span>
+                    {busy === t.title ? (
+                      <Loader2 className="h-4 w-4 flex-shrink-0 animate-spin text-accent-warm" />
+                    ) : (
+                      <ArrowRight className="h-4 w-4 flex-shrink-0 text-fg-tertiary transition-transform group-hover:translate-x-0.5 group-hover:text-accent-warm" />
+                    )}
+                  </button>
+                </li>
+              ))}
+            </ul>
+          )}
+
+          {error && <p className="mt-2 text-xs text-status-negative">{error}</p>}
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/articles/MarkdownToolbar.tsx b/src/components/articles/MarkdownToolbar.tsx
new file mode 100644
index 000000000..94bbbbaa2
--- /dev/null
+++ b/src/components/articles/MarkdownToolbar.tsx
@@ -0,0 +1,134 @@
+'use client';
+
+import {
+  Bold,
+  Italic,
+  Heading2,
+  Heading3,
+  List,
+  ListOrdered,
+  Quote,
+  Link2,
+  Code,
+} from 'lucide-react';
+import type { MarkdownActions } from './useMarkdownTextarea';
+import { cn } from '@/lib/utils';
+
+/**
+ * Formatting toolbar for the markdown article body. Purely drives
+ * {@link MarkdownActions} — the body stays plain markdown (SSOT), rendered
+ * safely by ArticleMarkdown. Design-token styling only.
+ */
+export default function MarkdownToolbar({
+  actions,
+  disabled,
+}: {
+  actions: MarkdownActions;
+  disabled?: boolean;
+}) {
+  const btn =
+    'flex h-8 w-8 items-center justify-center rounded-md text-fg-secondary transition-colors hover:bg-surface-raised hover:text-fg-primary disabled:cursor-not-allowed disabled:opacity-40';
+
+  const Divider = () => <span className="mx-0.5 h-5 w-px bg-subtle" aria-hidden />;
+
+  return (
+    <div
+      className="flex flex-wrap items-center gap-0.5 rounded-t-md border border-b-0 border-subtle bg-surface-raised/30 px-1.5 py-1"
+      role="toolbar"
+      aria-label="Formatting"
+    >
+      <button
+        type="button"
+        className={cn(btn)}
+        disabled={disabled}
+        onClick={() => actions.wrap('**', '**', 'bold')}
+        title="Bold (⌘B)"
+        aria-label="Bold"
+      >
+        <Bold className="h-4 w-4" />
+      </button>
+      <button
+        type="button"
+        className={cn(btn)}
+        disabled={disabled}
+        onClick={() => actions.wrap('*', '*', 'italic')}
+        title="Italic (⌘I)"
+        aria-label="Italic"
+      >
+        <Italic className="h-4 w-4" />
+      </button>
+      <button
+        type="button"
+        className={cn(btn)}
+        disabled={disabled}
+        onClick={() => actions.wrap('`', '`', 'code')}
+        title="Inline code"
+        aria-label="Inline code"
+      >
+        <Code className="h-4 w-4" />
+      </button>
+      <Divider />
+      <button
+        type="button"
+        className={cn(btn)}
+        disabled={disabled}
+        onClick={() => actions.prefixLines('## ')}
+        title="Heading"
+        aria-label="Heading 2"
+      >
+        <Heading2 className="h-4 w-4" />
+      </button>
+      <button
+        type="button"
+        className={cn(btn)}
+        disabled={disabled}
+        onClick={() => actions.prefixLines('### ')}
+        title="Subheading"
+        aria-label="Heading 3"
+      >
+        <Heading3 className="h-4 w-4" />
+      </button>
+      <Divider />
+      <button
+        type="button"
+        className={cn(btn)}
+        disabled={disabled}
+        onClick={() => actions.prefixLines('- ')}
+        title="Bulleted list"
+        aria-label="Bulleted list"
+      >
+        <List className="h-4 w-4" />
+      </button>
+      <button
+        type="button"
+        className={cn(btn)}
+        disabled={disabled}
+        onClick={() => actions.prefixLines('1. ')}
+        title="Numbered list"
+        aria-label="Numbered list"
+      >
+        <ListOrdered className="h-4 w-4" />
+      </button>
+      <button
+        type="button"
+        className={cn(btn)}
+        disabled={disabled}
+        onClick={() => actions.prefixLines('> ')}
+        title="Quote"
+        aria-label="Quote"
+      >
+        <Quote className="h-4 w-4" />
+      </button>
+      <button
+        type="button"
+        className={cn(btn)}
+        disabled={disabled}
+        onClick={() => actions.insertLink()}
+        title="Link"
+        aria-label="Link"
+      >
+        <Link2 className="h-4 w-4" />
+      </button>
+    </div>
+  );
+}
diff --git a/src/components/articles/useMarkdownTextarea.ts b/src/components/articles/useMarkdownTextarea.ts
new file mode 100644
index 000000000..bb61a8d52
--- /dev/null
+++ b/src/components/articles/useMarkdownTextarea.ts
@@ -0,0 +1,93 @@
+'use client';
+
+import { useCallback, type RefObject } from 'react';
+
+/**
+ * Selection-aware markdown editing for a controlled <textarea>. Each action
+ * computes the new value + caret range, pushes the value through the parent's
+ * onChange, then restores the selection on the next frame (the textarea DOM node
+ * is stable via the ref, so the caret survives React's re-render).
+ */
+export interface MarkdownActions {
+  /** Wrap the selection with `before`/`after` (e.g. ** ** ); inserts `placeholder` if empty. */
+  wrap: (before: string, after?: string, placeholder?: string) => void;
+  /** Prefix each selected line (e.g. "## ", "- ", "> "). Toggles the prefix off if already present. */
+  prefixLines: (prefix: string) => void;
+  /** Insert a markdown link around the selection. */
+  insertLink: () => void;
+}
+
+export function useMarkdownTextarea(
+  ref: RefObject<HTMLTextAreaElement | null>,
+  value: string,
+  onChange: (next: string) => void
+): MarkdownActions {
+  const apply = useCallback(
+    (next: string, selStart: number, selEnd: number) => {
+      onChange(next);
+      requestAnimationFrame(() => {
+        const el = ref.current;
+        if (!el) {
+          return;
+        }
+        el.focus();
+        el.setSelectionRange(selStart, selEnd);
+      });
+    },
+    [onChange, ref]
+  );
+
+  const wrap = useCallback(
+    (before: string, after = before, placeholder = 'text') => {
+      const el = ref.current;
+      if (!el) {
+        return;
+      }
+      const start = el.selectionStart;
+      const end = el.selectionEnd;
+      const selected = value.slice(start, end) || placeholder;
+      const next = value.slice(0, start) + before + selected + after + value.slice(end);
+      apply(next, start + before.length, start + before.length + selected.length);
+    },
+    [apply, ref, value]
+  );
+
+  const prefixLines = useCallback(
+    (prefix: string) => {
+      const el = ref.current;
+      if (!el) {
+        return;
+      }
+      const start = el.selectionStart;
+      const end = el.selectionEnd;
+      const lineStart = value.lastIndexOf('\n', start - 1) + 1;
+      const block = value.slice(lineStart, end);
+      const allPrefixed = block.split('\n').every(l => l.startsWith(prefix));
+      const transformed = block
+        .split('\n')
+        .map(l => (allPrefixed ? l.slice(prefix.length) : prefix + l))
+        .join('\n');
+      const next = value.slice(0, lineStart) + transformed + value.slice(end);
+      const delta = transformed.length - block.length;
+      apply(next, lineStart, end + delta);
+    },
+    [apply, ref, value]
+  );
+
+  const insertLink = useCallback(() => {
+    const el = ref.current;
+    if (!el) {
+      return;
+    }
+    const start = el.selectionStart;
+    const end = el.selectionEnd;
+    const label = value.slice(start, end) || 'link text';
+    const snippet = `[${label}](url)`;
+    const next = value.slice(0, start) + snippet + value.slice(end);
+    // Select the "url" placeholder so the user can type it immediately.
+    const urlStart = start + label.length + 3;
+    apply(next, urlStart, urlStart + 3);
+  }, [apply, ref, value]);
+
+  return { wrap, prefixLines, insertLink };
+}
diff --git a/src/components/timeline/PostAiButton.tsx b/src/components/timeline/PostAiButton.tsx
new file mode 100644
index 000000000..94535a928
--- /dev/null
+++ b/src/components/timeline/PostAiButton.tsx
@@ -0,0 +1,55 @@
+'use client';
+
+import { useState } from 'react';
+import { Sparkles, Loader2 } from 'lucide-react';
+import { fetchPostDraft } from '@/services/articles/ai-client';
+import { TIMELINE_SURFACE } from '@/config/timeline';
+import { cn } from '@/lib/utils';
+
+/**
+ * One-click "write me a post" — asks the AI writer for a short, engagement-
+ * sparking post grounded in the user's own interests, then fills the composer.
+ * Fails soft: a transient inline note, never a blocking error.
+ */
+export default function PostAiButton({
+  onDraft,
+  disabled,
+}: {
+  onDraft: (text: string) => void;
+  disabled?: boolean;
+}) {
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  async function go() {
+    if (busy || disabled) {
+      return;
+    }
+    setBusy(true);
+    setError(null);
+    try {
+      const draft = await fetchPostDraft({});
+      onDraft(draft.text);
+    } catch (e) {
+      setError(e instanceof Error ? e.message : 'Could not draft a post. Try again.');
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  return (
+    <div className="inline-flex items-center gap-2">
+      <button
+        type="button"
+        onClick={go}
+        disabled={busy || disabled}
+        className={cn(TIMELINE_SURFACE.chip, 'gap-1.5')}
+        title="Write a post with AI, grounded in your interests"
+      >
+        {busy ? <Loader2 className="h-4 w-4 animate-spin" /> : <Sparkles className="h-4 w-4" />}
+        {busy ? 'Writing…' : 'Write with AI'}
+      </button>
+      {error && <span className="text-xs text-status-negative">{error}</span>}
+    </div>
+  );
+}
diff --git a/src/components/timeline/TimelineComposer.tsx b/src/components/timeline/TimelineComposer.tsx
index 2e164e04a..1d2acc078 100644
--- a/src/components/timeline/TimelineComposer.tsx
+++ b/src/components/timeline/TimelineComposer.tsx
@@ -23,6 +23,7 @@ import {
   OfflineIndicator,
   ContextIndicator,
 } from './ComposerShared';
+import PostAiButton from './PostAiButton';
 
 export interface TimelineComposerProps {
   targetOwnerId?: string;
@@ -190,6 +191,9 @@ const TimelineComposer = React.memo(function TimelineComposer({
 
           <div className="mt-4 flex items-center justify-between border-t border-subtle pt-3">
             <div className="flex flex-wrap items-center gap-2">
+              {!parentEventId && (
+                <PostAiButton onDraft={postComposer.setContent} disabled={postComposer.isPosting} />
+              )}
               {!simpleMode && <TextFormatToolbar onFormat={handleFormat} />}
 
               {!simpleMode && allowProjectSelection && postComposer.userProjects.length > 0 && (
diff --git a/src/services/articles/ai-client.ts b/src/services/articles/ai-client.ts
new file mode 100644
index 000000000..2a160b53f
--- /dev/null
+++ b/src/services/articles/ai-client.ts
@@ -0,0 +1,45 @@
+/**
+ * Browser client for the AI writing endpoints. Thin fetch wrappers that return
+ * typed drafts/topics, or throw a friendly Error the composer can surface.
+ */
+
+import type {
+  ArticleDraft,
+  PostDraft,
+  ProposedTopic,
+  WritingKind,
+} from '@/services/cat/writing-types';
+
+async function postJson<T>(url: string, body: unknown): Promise<T> {
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+  const json = await res.json().catch(() => null);
+  if (!res.ok || !json?.success) {
+    throw new Error(json?.error || 'The AI writer is unavailable right now. Please try again.');
+  }
+  return json.data as T;
+}
+
+export function fetchWritingTopics(opts: {
+  kind?: WritingKind | 'any';
+  count?: number;
+  focus?: string;
+}): Promise<ProposedTopic[]> {
+  return postJson<{ topics: ProposedTopic[] }>('/api/ai/writing/topics', opts).then(d => d.topics);
+}
+
+export function fetchArticleDraft(opts: { topic?: string; focus?: string }): Promise<ArticleDraft> {
+  return postJson<{ draft: ArticleDraft }>('/api/ai/writing/draft', {
+    mode: 'article',
+    ...opts,
+  }).then(d => d.draft);
+}
+
+export function fetchPostDraft(opts: { topic?: string; focus?: string }): Promise<PostDraft> {
+  return postJson<{ draft: PostDraft }>('/api/ai/writing/draft', { mode: 'post', ...opts }).then(
+    d => d.draft
+  );
+}
diff --git a/src/services/cat/platform-llm.ts b/src/services/cat/platform-llm.ts
new file mode 100644
index 000000000..5f959c06e
--- /dev/null
+++ b/src/services/cat/platform-llm.ts
@@ -0,0 +1,142 @@
+/**
+ * Shared platform-LLM call for structured (JSON) Cat features. Mirrors the
+ * provider selection the offer-engine established (Groq preferred for short/fast
+ * work, OpenRouter free pool for long-form) and returns the raw model content
+ * string, or null on any failure so callers degrade gracefully.
+ *
+ * Free-pool only — needs GROQ_API_KEY and/or OPENROUTER_API_KEY on the box
+ * (already set; platform Cat runs on them). Never touches Cat Credits / NWC.
+ */
+
+import { logger } from '@/utils/logger';
+import { DEFAULT_FREE_MODEL_ID } from '@/config/ai-models';
+
+// Capable, JSON-reliable defaults. Groq is fast + cheap for short work; the
+// OpenRouter free 120B handles long-form with a larger output budget than
+// Groq's free tier (which caps output tokens for TPM reasons).
+const GROQ_MODEL = 'llama-3.3-70b-versatile';
+const OPENROUTER_SHORT_MODEL = 'meta-llama/llama-4-maverick:free';
+const OPENROUTER_LONGFORM_MODEL = DEFAULT_FREE_MODEL_ID; // 'openai/gpt-oss-120b:free'
+
+export interface PlatformJsonOpts {
+  temperature?: number;
+  maxTokens?: number;
+  /** Long-form (article bodies): prefer the OpenRouter 120B for larger output. */
+  longform?: boolean;
+}
+
+interface Provider {
+  url: string;
+  model: string;
+  apiKey: string;
+  isOpenRouter: boolean;
+}
+
+function resolveProvider(longform: boolean): Provider | null {
+  const groqKey = process.env.GROQ_API_KEY;
+  const openRouterKey = process.env.OPENROUTER_API_KEY;
+
+  // Long-form prefers OpenRouter's larger free model; short work prefers Groq's speed.
+  if (longform && openRouterKey) {
+    return openRouter(openRouterKey, OPENROUTER_LONGFORM_MODEL);
+  }
+  if (groqKey) {
+    return {
+      url: 'https://api.groq.com/openai/v1/chat/completions',
+      model: GROQ_MODEL,
+      apiKey: groqKey,
+      isOpenRouter: false,
+    };
+  }
+  if (openRouterKey) {
+    return openRouter(openRouterKey, longform ? OPENROUTER_LONGFORM_MODEL : OPENROUTER_SHORT_MODEL);
+  }
+  return null;
+}
+
+function openRouter(apiKey: string, model: string): Provider {
+  return {
+    url: 'https://openrouter.ai/api/v1/chat/completions',
+    model,
+    apiKey,
+    isOpenRouter: true,
+  };
+}
+
+/**
+ * Call the platform LLM with a system+user prompt and JSON response mode.
+ * Returns the raw content string (expected to be JSON) or null.
+ */
+export async function callPlatformJson(
+  system: string,
+  user: string,
+  opts: PlatformJsonOpts = {}
+): Promise<string | null> {
+  const provider = resolveProvider(!!opts.longform);
+  if (!provider) {
+    logger.warn('platform-llm: no platform AI key configured', {}, 'PlatformLLM');
+    return null;
+  }
+
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+    Authorization: `Bearer ${provider.apiKey}`,
+  };
+  if (provider.isOpenRouter) {
+    headers['HTTP-Referer'] = process.env.NEXT_PUBLIC_APP_URL || 'https://orangecat.ch';
+  }
+
+  try {
+    const response = await fetch(provider.url, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({
+        model: provider.model,
+        messages: [
+          { role: 'system', content: system },
+          { role: 'user', content: user },
+        ],
+        temperature: opts.temperature ?? 0.6,
+        max_tokens: opts.maxTokens ?? (opts.longform ? 4000 : 1400),
+        response_format: { type: 'json_object' },
+      }),
+    });
+    if (!response.ok) {
+      logger.warn('platform-llm: model call failed', { status: response.status }, 'PlatformLLM');
+      return null;
+    }
+    const json = (await response.json()) as { choices?: { message?: { content?: string } }[] };
+    return json.choices?.[0]?.message?.content ?? null;
+  } catch (err) {
+    logger.warn('platform-llm: model call threw', { err: String(err) }, 'PlatformLLM');
+    return null;
+  }
+}
+
+/**
+ * Defensive JSON parse for model output: tolerates ```json fences and leading
+ * prose by extracting the first balanced object/array. Returns null on failure.
+ */
+export function parseJsonLoose<T = unknown>(raw: string | null): T | null {
+  if (!raw) {
+    return null;
+  }
+  const cleaned = raw
+    .replace(/^```(?:json)?/i, '')
+    .replace(/```$/, '')
+    .trim();
+  try {
+    return JSON.parse(cleaned) as T;
+  } catch {
+    // Fall back to the first {...} or [...] span.
+    const match = cleaned.match(/[[{][\s\S]*[\]}]/);
+    if (match) {
+      try {
+        return JSON.parse(match[0]) as T;
+      } catch {
+        /* fall through */
+      }
+    }
+    return null;
+  }
+}
diff --git a/src/services/cat/writing-engine.ts b/src/services/cat/writing-engine.ts
new file mode 100644
index 000000000..d7df8f2f8
--- /dev/null
+++ b/src/services/cat/writing-engine.ts
@@ -0,0 +1,252 @@
+/**
+ * Writing engine — the user's AI writing companion.
+ *
+ * Given what OrangeCat knows about a person (profile, entities, durable memories,
+ * and the posts they've already written = their voice), it proposes topics they'd
+ * genuinely want to write, and drafts full posts or long-form articles in their
+ * voice. Mirrors the offer-engine's grounding + never-throw contract: any failure
+ * returns [] / null so the composer degrades to a plain blank editor.
+ *
+ * Hard grounding rules (same lineage as the "Cat invented personas" fix): never
+ * fabricate facts, stats, quotes, or people; ground every suggestion in a real
+ * context item; Bitcoin is BTC, never "sats".
+ */
+
+import type { AnySupabaseClient } from '@/lib/supabase/types';
+import { fetchFullContextForCat } from '@/services/ai/document-context';
+import { buildFullContextString } from '@/services/ai/context-string-builder';
+import { getUserActorId } from '@/domain/actors';
+import { TIMELINE_TABLES } from '@/config/database-tables';
+import { ARTICLE_LIMITS } from '@/config/articles';
+import { TIMELINE_CONTENT_LIMITS } from '@/config/timeline';
+import { listMemories } from './memory';
+import { callPlatformJson, parseJsonLoose } from './platform-llm';
+import type { ArticleDraft, PostDraft, ProposedTopic, WritingKind } from './writing-types';
+import { logger } from '@/utils/logger';
+
+export type { ArticleDraft, PostDraft, ProposedTopic, WritingKind } from './writing-types';
+
+const MAX_TOPICS = 8;
+
+const GROUNDING_RULES = `GROUNDING RULES (hard constraints):
+- Ground everything in something SPECIFIC and REAL from the context below (their work, skills, entities, stated interests, or the posts they've already written).
+- NEVER invent facts, statistics, quotes, events, or people. If the context is thin, write about the themes that ARE present rather than fabricating detail.
+- Write in the user's own voice — match the tone of the posts they've already written when samples are provided.
+- Money is Bitcoin (BTC) or a fiat currency; NEVER write "sats" or "satoshis".
+- No clichés, no clickbait, no hashtag spam, no corporate filler. Sound like a real, thoughtful person.`;
+
+async function fetchRecentAuthored(supabase: AnySupabaseClient, actorId: string): Promise<string> {
+  try {
+    const { data } = await supabase
+      .from(TIMELINE_TABLES.EVENTS)
+      .select('title, description, metadata')
+      .eq('actor_id', actorId)
+      .eq('metadata->>is_user_post', 'true')
+      .eq('is_deleted', false)
+      .order('event_timestamp', { ascending: false })
+      .limit(20);
+
+    const rows = (data ?? []) as Array<{
+      title: string | null;
+      description: string | null;
+      metadata: { is_article?: boolean } | null;
+    }>;
+    const lines = rows
+      .map(r => {
+        const text = (r.description || r.title || '').replace(/\s+/g, ' ').trim().slice(0, 200);
+        if (!text) {
+          return '';
+        }
+        return `- ${r.metadata?.is_article ? '[article] ' : ''}${text}`;
+      })
+      .filter(Boolean);
+    return lines.length ? lines.join('\n') : '(none yet)';
+  } catch {
+    return '(none yet)';
+  }
+}
+
+async function buildWriterContext(
+  supabase: AnySupabaseClient,
+  userId: string
+): Promise<{ contextBlob: string; memoryBlob: string; recentBlob: string }> {
+  const [context, memories, actorId] = await Promise.all([
+    fetchFullContextForCat(supabase, userId),
+    listMemories(supabase, userId),
+    getUserActorId(supabase, userId),
+  ]);
+  const contextBlob = buildFullContextString(context);
+  const memoryBlob = memories.length
+    ? memories
+        .slice(0, 40)
+        .map(m => `- ${m.content}`)
+        .join('\n')
+    : '(none)';
+  const recentBlob = actorId ? await fetchRecentAuthored(supabase, actorId) : '(none yet)';
+  return { contextBlob, memoryBlob, recentBlob };
+}
+
+function contextPrompt(
+  ctx: { contextBlob: string; memoryBlob: string; recentBlob: string },
+  focus?: string
+): string {
+  return `Everything OrangeCat knows about this user:
+
+${ctx.contextBlob}
+
+DURABLE MEMORIES:
+${ctx.memoryBlob}
+
+POSTS THEY'VE ALREADY WRITTEN (their voice — match this tone):
+${ctx.recentBlob}
+${focus ? `\nThe user asked to focus on: ${focus}\n` : ''}`;
+}
+
+// ---------------------------------------------------------------------------
+// Topic suggestions
+// ---------------------------------------------------------------------------
+
+export async function suggestTopics(
+  supabase: AnySupabaseClient,
+  userId: string,
+  opts?: { count?: number; kind?: WritingKind | 'any'; focus?: string }
+): Promise<ProposedTopic[]> {
+  const count = Math.min(Math.max(opts?.count ?? 5, 1), MAX_TOPICS);
+  const kind = opts?.kind ?? 'any';
+  const ctx = await buildWriterContext(supabase, userId);
+
+  const kindLine =
+    kind === 'any'
+      ? 'Mix quick POSTS (a sharp thought that sparks replies) and longer ARTICLES (a topic worth 3–8 minutes of reading). Set "kind" to "post" or "article" per idea.'
+      : `Every idea must be a ${kind.toUpperCase()} ("kind":"${kind}").`;
+
+  const system = `You are the user's writing companion inside OrangeCat — a Bitcoin-native platform for expressing ideas in text. Suggest specific things THIS person would genuinely want to write and would write well, so they publish more often.
+
+${kindLine}
+
+Each idea: a concrete, specific "title" (the headline/topic, not a category) and a one-line "angle" (the take or hook, in their voice). Favor ideas that invite other people to respond and share their own experience.
+
+${GROUNDING_RULES}
+
+Output ONLY JSON: {"topics":[{"kind":"post","title":"...","angle":"..."}]}. Return up to ${count} ideas. Quality over quantity — fewer strong ideas beat filler.`;
+
+  const raw = await callPlatformJson(
+    system,
+    `${contextPrompt(ctx, opts?.focus)}\nPropose up to ${count} topics as JSON.`,
+    {
+      temperature: 0.75,
+      maxTokens: 1200,
+    }
+  );
+  return parseTopics(raw, count, kind);
+}
+
+function parseTopics(
+  raw: string | null,
+  count: number,
+  kind: WritingKind | 'any'
+): ProposedTopic[] {
+  const parsed = parseJsonLoose<{ topics?: unknown[] } | unknown[]>(raw);
+  const arr: unknown[] = Array.isArray(parsed) ? parsed : (parsed?.topics ?? []);
+  return arr
+    .filter(
+      (t): t is { kind?: string; title: string; angle?: string } =>
+        !!t &&
+        typeof (t as { title?: unknown }).title === 'string' &&
+        (t as { title: string }).title.trim().length > 0
+    )
+    .map(t => {
+      const k: WritingKind =
+        t.kind === 'article' || t.kind === 'post'
+          ? t.kind
+          : kind === 'article'
+            ? 'article'
+            : 'post';
+      return {
+        kind: kind === 'any' ? k : kind,
+        title: t.title.trim().slice(0, ARTICLE_LIMITS.title),
+        angle: String(t.angle ?? '')
+          .trim()
+          .slice(0, 200),
+      };
+    })
+    .slice(0, count);
+}
+
+// ---------------------------------------------------------------------------
+// Post draft
+// ---------------------------------------------------------------------------
+
+export async function draftPost(
+  supabase: AnySupabaseClient,
+  userId: string,
+  opts?: { topic?: string; focus?: string }
+): Promise<PostDraft | null> {
+  const ctx = await buildWriterContext(supabase, userId);
+  const system = `You are the user's writing companion inside OrangeCat. Write ONE short post in the user's authentic voice that they can publish right now. It should share a genuine, specific thought or question and invite other people to respond with their own take — the goal is to get a real conversation going.
+
+- Keep it under ${TIMELINE_CONTENT_LIMITS.post} characters. No title, no preamble, no hashtags, no emoji spam.
+- Sound like a person, not a brand. One clear idea.
+
+${GROUNDING_RULES}
+
+Output ONLY JSON: {"text":"the post"}.`;
+
+  const userPrompt = `${contextPrompt(ctx, opts?.focus)}${
+    opts?.topic ? `\nWrite the post about: ${opts.topic}\n` : ''
+  }\nWrite the post as JSON.`;
+
+  const raw = await callPlatformJson(system, userPrompt, { temperature: 0.8, maxTokens: 600 });
+  const parsed = parseJsonLoose<{ text?: unknown }>(raw);
+  const text = typeof parsed?.text === 'string' ? parsed.text.trim() : '';
+  if (!text) {
+    logger.warn('writing-engine: empty post draft', {}, 'WritingEngine');
+    return null;
+  }
+  return { text: text.slice(0, TIMELINE_CONTENT_LIMITS.editPost) };
+}
+
+// ---------------------------------------------------------------------------
+// Article draft
+// ---------------------------------------------------------------------------
+
+export async function draftArticle(
+  supabase: AnySupabaseClient,
+  userId: string,
+  opts?: { topic?: string; focus?: string }
+): Promise<ArticleDraft | null> {
+  const ctx = await buildWriterContext(supabase, userId);
+  const system = `You are the user's writing companion inside OrangeCat — a Bitcoin-native platform for long-form expression. Write a COMPLETE, publishable long-form article in the user's authentic voice.
+
+Structure:
+- A compelling, specific "title" (a real headline, not a category).
+- A one-sentence "excerpt" that makes someone want to read.
+- A "body" in Markdown: an engaging opening, 2–5 sections with "## " subheadings, short readable paragraphs, and a bulleted list where it genuinely helps. Aim for a 3–7 minute read. End with a thought that invites the reader to reflect or respond. Do NOT repeat the title as an H1 inside the body.
+
+${GROUNDING_RULES}
+
+Output ONLY JSON: {"title":"...","excerpt":"...","body":"...markdown..."}.`;
+
+  const userPrompt = `${contextPrompt(ctx, opts?.focus)}${
+    opts?.topic ? `\nWrite the article about: ${opts.topic}\n` : ''
+  }\nWrite the article as JSON.`;
+
+  const raw = await callPlatformJson(system, userPrompt, {
+    temperature: 0.7,
+    maxTokens: 4000,
+    longform: true,
+  });
+  const parsed = parseJsonLoose<{ title?: unknown; excerpt?: unknown; body?: unknown }>(raw);
+  const title = typeof parsed?.title === 'string' ? parsed.title.trim() : '';
+  const body = typeof parsed?.body === 'string' ? parsed.body.trim() : '';
+  if (!title || !body) {
+    logger.warn('writing-engine: incomplete article draft', {}, 'WritingEngine');
+    return null;
+  }
+  const excerpt = typeof parsed?.excerpt === 'string' ? parsed.excerpt.trim() : '';
+  return {
+    title: title.slice(0, ARTICLE_LIMITS.title),
+    excerpt: excerpt.slice(0, ARTICLE_LIMITS.excerpt),
+    body: body.slice(0, ARTICLE_LIMITS.body),
+  };
+}
diff --git a/src/services/cat/writing-types.ts b/src/services/cat/writing-types.ts
new file mode 100644
index 000000000..75a3602eb
--- /dev/null
+++ b/src/services/cat/writing-types.ts
@@ -0,0 +1,24 @@
+/**
+ * Shared writing-engine types — client-safe (no server imports), so both the
+ * server engine and the browser composer import them from one place.
+ */
+
+export type WritingKind = 'post' | 'article';
+
+export interface ProposedTopic {
+  kind: WritingKind;
+  /** The headline / topic itself. */
+  title: string;
+  /** One line on the angle — why it's worth writing, in their voice. */
+  angle: string;
+}
+
+export interface ArticleDraft {
+  title: string;
+  excerpt: string;
+  body: string;
+}
+
+export interface PostDraft {
+  text: string;
+}