plotlink-ows 0.1.15 → 1.0.0

package/app/lib/publish.ts

@@ -1,38 +1,67 @@
 /**
  * PlotLink publish flow — uploads content to IPFS and publishes on-chain via OWS wallet.
  */
-import { createPublicClient, http, encodeFunctionData, keccak256, toBytes, decodeEventLog, type Hex } from "viem";
+import { createPublicClient, createWalletClient, http, keccak256, toBytes, decodeEventLog, serializeTransaction, type Hex } from "viem";
 import { base } from "viem/chains";
-import { STORY_FACTORY_ABI, mcv2BondAbi } from "../../packages/cli/src/sdk/abi";
-import { uploadWithRetry } from "../../packages/cli/src/sdk/ipfs";
-import { signAndSendAgent } from "../../lib/ows/wallet";
+import { toAccount } from "viem/accounts";
+import { storyFactoryAbi, mcv2BondAbi } from "../../packages/cli/src/sdk/abi";
+import {
+  signTransaction as owsSignTx,
+  signMessage as owsSignMsg,
+} from "@open-wallet-standard/core";
 
 // Contract addresses (Base mainnet)
 const STORY_FACTORY = "0x9D2AE1E99D0A6300bfcCF41A82260374e38744Cf" as const;
 const MCV2_BOND = "0xc5a076cad94176c2996B32d8466Be1cE757FAa27" as const;
 
+const rpcUrl = process.env.NEXT_PUBLIC_RPC_URL || "https://mainnet.base.org";
 const publicClient = createPublicClient({
   chain: base,
-  transport: http(process.env.NEXT_PUBLIC_RPC_URL || "https://mainnet.base.org"),
+  transport: http(rpcUrl),
 });
 
-function getFilebaseConfig() {
-  return {
-    accessKey: process.env.FILEBASE_ACCESS_KEY || "",
-    secretKey: process.env.FILEBASE_SECRET_KEY || "",
-    bucket: process.env.FILEBASE_BUCKET || "",
-  };
+/** Parse OWS signature into viem-compatible r,s,v */
+function parseEvmSignature(sigHex: string, recoveryId?: number): { r: Hex; s: Hex; v: bigint } {
+  const sig = sigHex.startsWith("0x") ? sigHex.slice(2) : sigHex;
+  const r = `0x${sig.slice(0, 64)}` as Hex;
+  const s = `0x${sig.slice(64, 128)}` as Hex;
+  // recovery id from OWS or from the last byte of signature
+  const v = recoveryId !== undefined ? BigInt(recoveryId + 27) : BigInt(parseInt(sig.slice(128, 130), 16));
+  return { r, s, v };
+}
+
+/** Create a viem-compatible account backed by OWS wallet (same pattern as claw-on-chain) */
+export function createOwsAccount(walletName: string, address: `0x${string}`) {
+  const passphrase = process.env.OWS_PASSPHRASE;
+  return toAccount({
+    address,
+    signMessage: async ({ message }) => {
+      const msg = typeof message === "string" ? message : typeof message.raw === "string" ? message.raw : Buffer.from(message.raw).toString("hex");
+      const result = owsSignMsg(walletName, "eip155:8453", msg, passphrase);
+      return (result.signature.startsWith("0x") ? result.signature : `0x${result.signature}`) as Hex;
+    },
+    signTransaction: async (tx) => {
+      const unsigned = serializeTransaction(tx);
+      const hexWithout0x = unsigned.startsWith("0x") ? unsigned.slice(2) : unsigned;
+      const result = owsSignTx(walletName, "eip155:8453", hexWithout0x, passphrase);
+      const sig = parseEvmSignature(result.signature, result.recoveryId);
+      return serializeTransaction(tx, sig);
+    },
+    signTypedData: async () => { throw new Error("signTypedData not implemented"); },
+  });
 }
 
 export interface PublishResult {
   txHash: string;
   contentCid: string;
   storylineId?: number;
+  plotIndex?: number;
   gasCost?: string;
+  indexError?: string;
 }
 
 export interface PublishProgress {
-  step: "uploading" | "estimating" | "signing" | "broadcasting" | "confirming" | "done" | "error";
+  step: "uploading" | "estimating" | "signing" | "broadcasting" | "confirming" | "indexing" | "done" | "error";
   message: string;
   txHash?: string;
   contentCid?: string;
@@ -40,21 +69,98 @@ export interface PublishProgress {
   error?: string;
 }
 
+// Indexing retry tuning (per #103 RCA — combo A+B):
+// - 8s initial delay lets the on-chain tx propagate to plotlink.xyz's RPC
+//   and gives Filebase → public IPFS gateway propagation a head start.
+// - 10 attempts × 30s interval ≈ 4.5 min total, fitting inside plotlink.xyz's
+//   5-min indexable window so users don't escalate to a full Retry Publish
+//   (which would mint another chainPlot tx and inflate the on-chain index).
+const INDEX_INITIAL_DELAY_MS = 8_000;
+const INDEX_RETRY_ATTEMPTS = 10;
+const INDEX_RETRY_INTERVAL_MS = 30_000;
+
 /**
- * Upload story content to IPFS via Filebase.
+ * POST to plotlink.xyz's indexer with an initial delay and a retry loop.
+ * Streams "Indexing… (attempt N/M)" progress so the publish flow surfaces
+ * the in-progress state instead of an immediate failure.
+ *
+ * Returns undefined on success, or the final error message after all
+ * attempts have failed.
  */
-export async function uploadToIPFS(content: string, title: string, genre?: string): Promise<string> {
-  const filebaseConfig = getFilebaseConfig();
-  if (!filebaseConfig.accessKey || !filebaseConfig.secretKey) {
-    throw new Error("Filebase not configured. Set FILEBASE_ACCESS_KEY and FILEBASE_SECRET_KEY in .env");
+async function indexWithDelayAndRetry(
+  endpoint: "plot" | "storyline",
+  body: Record<string, unknown>,
+  onProgress: (progress: PublishProgress) => void,
+  txHash: string,
+  contentCid: string,
+): Promise<string | undefined> {
+  const PLOTLINK_URL = process.env.NEXT_PUBLIC_APP_URL || "https://plotlink.xyz";
+  const url = `${PLOTLINK_URL}/api/index/${endpoint}`;
+
+  onProgress({
+    step: "indexing",
+    message: `Indexing… waiting ${INDEX_INITIAL_DELAY_MS / 1000}s for on-chain propagation`,
+    txHash,
+    contentCid,
+  });
+  await new Promise((r) => setTimeout(r, INDEX_INITIAL_DELAY_MS));
+
+  let lastError: string | undefined;
+  for (let attempt = 1; attempt <= INDEX_RETRY_ATTEMPTS; attempt++) {
+    onProgress({
+      step: "indexing",
+      message: `Indexing… (attempt ${attempt}/${INDEX_RETRY_ATTEMPTS})`,
+      txHash,
+      contentCid,
+    });
+
+    try {
+      const indexRes = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+      });
+      const indexBody = await indexRes.json().catch(() => ({})) as Record<string, string>;
+      if (indexRes.ok && !indexBody.error) {
+        return undefined;
+      }
+      lastError = indexBody.error || `Indexing failed: HTTP ${indexRes.status}`;
+    } catch (err) {
+      lastError = err instanceof Error ? err.message : "Indexing request failed";
+    }
+
+    if (attempt < INDEX_RETRY_ATTEMPTS) {
+      await new Promise((r) => setTimeout(r, INDEX_RETRY_INTERVAL_MS));
+    }
   }
 
+  console.error(`Indexing failed for tx ${txHash} after ${INDEX_RETRY_ATTEMPTS} attempts:`, lastError);
+  return lastError;
+}
+
+/**
+ * Upload story content to IPFS via PlotLink's API (plotlink.xyz/api/upload).
+ * PlotLink handles Filebase credentials server-side.
+ */
+export async function uploadToIPFS(content: string, title: string, genre?: string): Promise<string> {
+  const PLOTLINK_URL = process.env.NEXT_PUBLIC_APP_URL || "https://plotlink.xyz";
   const metadata = JSON.stringify({ title, genre, content });
   const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 40);
   const key = `plotlink/storylines/${Date.now()}-${slug}.json`;
 
-  const cid = await uploadWithRetry(metadata, key, filebaseConfig);
-  return cid;
+  const res = await fetch(`${PLOTLINK_URL}/api/upload`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ content: metadata, key }),
+  });
+
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({})) as Record<string, string>;
+    throw new Error(err.error || `Upload failed: HTTP ${res.status}`);
+  }
+
+  const data = await res.json() as { cid: string };
+  return data.cid;
 }
 
 /**
@@ -85,7 +191,7 @@ export async function estimatePublishCost(
     to: STORY_FACTORY,
     value: creationFee,
     data: encodeFunctionData({
-      abi: STORY_FACTORY_ABI,
+      abi: storyFactoryAbi,
       functionName: "createStoryline",
       args: [title, contentCid, contentHash, true],
     }),
@@ -110,9 +216,9 @@ export async function getEthBalance(address: string): Promise<bigint> {
 }
 
 /**
- * Wait for transaction confirmation and decode storylineId from event.
+ * Wait for tx confirmation and compute gas cost.
  */
-async function waitForConfirmation(txHash: string): Promise<{ storylineId: number; gasCost: string }> {
+async function waitForReceipt(txHash: string) {
   const receipt = await publicClient.waitForTransactionReceipt({
     hash: txHash as `0x${string}`,
   });
@@ -123,8 +229,6 @@ async function waitForConfirmation(txHash: string): Promise<{ storylineId: numbe
 
   // Compute actual total cost: gasUsed * effectiveGasPrice + tx value (creation fee)
   const gasOnly = receipt.gasUsed * receipt.effectiveGasPrice;
-  const txValue = receipt.logs.length > 0 ? BigInt(0) : BigInt(0); // value is in the tx itself
-  // Include creation fee from tx value — read from the original transaction
   let creationFeeUsed = BigInt(0);
   try {
     const tx = await publicClient.getTransaction({ hash: txHash as `0x${string}` });
@@ -132,11 +236,19 @@ async function waitForConfirmation(txHash: string): Promise<{ storylineId: numbe
   } catch { /* best effort */ }
   const gasCost = (gasOnly + creationFeeUsed).toString();
 
-  // Decode StorylineCreated event to get storylineId
+  return { receipt, gasCost };
+}
+
+/**
+ * Wait for storyline creation confirmation — decodes StorylineCreated event.
+ */
+async function waitForStorylineConfirmation(txHash: string): Promise<{ storylineId: number; gasCost: string }> {
+  const { receipt, gasCost } = await waitForReceipt(txHash);
+
   for (const log of receipt.logs) {
     try {
       const decoded = decodeEventLog({
-        abi: STORY_FACTORY_ABI,
+        abi: storyFactoryAbi,
         data: log.data,
         topics: log.topics,
       });
@@ -148,6 +260,30 @@ async function waitForConfirmation(txHash: string): Promise<{ storylineId: numbe
   throw new Error("Transaction succeeded but StorylineCreated event not found");
 }
 
+/**
+ * Wait for plot chain confirmation — decodes PlotChained event.
+ */
+async function waitForPlotConfirmation(txHash: string): Promise<{ plotIndex: number; gasCost: string }> {
+  const { receipt, gasCost } = await waitForReceipt(txHash);
+
+  for (const log of receipt.logs) {
+    try {
+      const decoded = decodeEventLog({
+        abi: storyFactoryAbi,
+        data: log.data,
+        topics: log.topics,
+      });
+      if (decoded.eventName === "PlotChained") {
+        // plotIndex is 0-based: genesis=0, plot-01=1, plot-02=2, etc.
+        // This matches plotlink.xyz URL convention: /story/{id}/{plotIndex}
+        return { plotIndex: Number((decoded.args as { plotIndex: bigint }).plotIndex), gasCost };
+      }
+    } catch { /* not our event */ }
+  }
+  // If we can't find PlotChained but receipt succeeded, still return (best effort)
+  return { plotIndex: -1, gasCost };
+}
+
 /**
  * Publish a new storyline to PlotLink on-chain.
  */
@@ -168,37 +304,114 @@ export async function publishStoryline(
   onProgress({ step: "estimating", message: "Fetching creation fee and estimating gas..." });
   const creationFee = await getCreationFee();
 
-  // Step 3: Build transaction with creation fee as value
-  const calldata = encodeFunctionData({
-    abi: STORY_FACTORY_ABI,
+  // Step 3: Create OWS-backed viem wallet client
+  onProgress({ step: "signing", message: "Signing transaction with OWS wallet..." });
+  const { listAgentWallets, getBaseAddress } = await import("../../lib/ows/wallet");
+  const wallets = listAgentWallets();
+  const owsWallet = wallets.find((w) => w.name === walletName);
+  if (!owsWallet) throw new Error("OWS wallet not found");
+  const address = getBaseAddress(owsWallet);
+  if (!address) throw new Error("No EVM address on wallet");
+
+  const account = createOwsAccount(walletName, address as `0x${string}`);
+  const walletClient = createWalletClient({ account, chain: base, transport: http(rpcUrl) });
+
+  // Step 4: Write contract via viem (handles signing + broadcasting)
+  onProgress({ step: "broadcasting", message: "Broadcasting transaction..." });
+  const txHash = await walletClient.writeContract({
+    address: STORY_FACTORY,
+    abi: storyFactoryAbi,
     functionName: "createStoryline",
     args: [title, contentCid, contentHash, true],
+    value: creationFee,
   });
 
-  // Step 4: Sign and send via OWS
-  onProgress({ step: "signing", message: "Signing transaction with OWS wallet..." });
-  const rpcUrl = process.env.NEXT_PUBLIC_RPC_URL || "https://mainnet.base.org";
+  // Step 5: Wait for confirmation and decode storylineId
+  onProgress({ step: "confirming", message: "Waiting for confirmation...", txHash, contentCid });
+  const confirmation = await waitForStorylineConfirmation(txHash);
 
-  const txHex = JSON.stringify({
-    to: STORY_FACTORY,
-    data: calldata,
-    value: `0x${creationFee.toString(16)}`,
+  // Index on PlotLink with delay + retry (per #103 RCA — combo A+B).
+  // Streams "Indexing…" progress so the user does not escalate to Retry Publish.
+  const indexError = await indexWithDelayAndRetry(
+    "storyline",
+    { txHash, content, genre },
+    onProgress,
+    txHash,
+    contentCid,
+  );
+
+  onProgress({
+    step: "done",
+    message: `Published! Storyline #${confirmation.storylineId}`,
+    txHash,
+    contentCid,
+    storylineId: confirmation.storylineId,
   });
 
+  return { txHash, contentCid, storylineId: confirmation.storylineId, gasCost: confirmation.gasCost, indexError };
+}
+
+/**
+ * Chain a new plot to an existing storyline on-chain.
+ */
+export async function publishPlot(
+  walletName: string,
+  storylineId: number,
+  title: string,
+  content: string,
+  genre: string | undefined,
+  onProgress: (progress: PublishProgress) => void,
+): Promise<PublishResult> {
+  // Step 1: Upload to IPFS
+  onProgress({ step: "uploading", message: "Uploading plot to IPFS..." });
+  const contentCid = await uploadToIPFS(content, title, genre);
+
+  // Step 2: Compute content hash
+  const contentHash = keccak256(toBytes(content));
+
+  // Step 3: Create OWS-backed viem wallet client
+  onProgress({ step: "signing", message: "Signing transaction with OWS wallet..." });
+  const { listAgentWallets, getBaseAddress } = await import("../../lib/ows/wallet");
+  const wallets = listAgentWallets();
+  const owsWallet = wallets.find((w) => w.name === walletName);
+  if (!owsWallet) throw new Error("OWS wallet not found");
+  const address = getBaseAddress(owsWallet);
+  if (!address) throw new Error("No EVM address on wallet");
+
+  const account = createOwsAccount(walletName, address as `0x${string}`);
+  const walletClient = createWalletClient({ account, chain: base, transport: http(rpcUrl) });
+
+  // Step 4: Write contract via viem
   onProgress({ step: "broadcasting", message: "Broadcasting transaction..." });
-  const result = signAndSendAgent(walletName, txHex, undefined, rpcUrl);
+  const txHash = await walletClient.writeContract({
+    address: STORY_FACTORY,
+    abi: storyFactoryAbi,
+    functionName: "chainPlot",
+    args: [BigInt(storylineId), title, contentCid, contentHash],
+  });
 
-  // Step 5: Wait for confirmation and decode storylineId
-  onProgress({ step: "confirming", message: "Waiting for confirmation...", txHash: result.txHash, contentCid });
-  const confirmation = await waitForConfirmation(result.txHash);
+  // Step 5: Wait for plot confirmation
+  onProgress({ step: "confirming", message: "Waiting for confirmation...", txHash, contentCid });
+  const confirmation = await waitForPlotConfirmation(txHash);
+
+  // Index on PlotLink with delay + retry (per #103 RCA — combo A+B).
+  // Pass content as fallback because IPFS stores JSON metadata wrapper,
+  // but on-chain hash is keccak256 of raw content only.
+  const indexError = await indexWithDelayAndRetry(
+    "plot",
+    { txHash, content },
+    onProgress,
+    txHash,
+    contentCid,
+  );
 
   onProgress({
     step: "done",
-    message: `Published! Storyline #${confirmation.storylineId}`,
-    txHash: result.txHash,
+    message: `Plot chained to storyline #${storylineId}`,
+    txHash,
     contentCid,
-    storylineId: confirmation.storylineId,
+    storylineId,
   });
 
-  return { txHash: result.txHash, contentCid, storylineId: confirmation.storylineId, gasCost: confirmation.gasCost };
+  return { txHash, contentCid, storylineId, plotIndex: confirmation.plotIndex >= 0 ? confirmation.plotIndex : undefined, gasCost: confirmation.gasCost, indexError };
 }

package/app/prisma/schema.prisma

@@ -19,39 +19,3 @@ model Setting {
   key   String @id
   value String
 }
-
-model StorySession {
-  id        String    @id @default(cuid())
-  title     String    @default("Untitled Story")
-  genre     String?
-  status    String    @default("active") // active, finalized, archived
-  createdAt DateTime  @default(now())
-  updatedAt DateTime  @updatedAt
-  messages  Message[]
-  drafts    Draft[]
-}
-
-model Message {
-  id        String       @id @default(cuid())
-  sessionId String
-  session   StorySession @relation(fields: [sessionId], references: [id], onDelete: Cascade)
-  role      String       // user, assistant, system
-  content   String
-  createdAt DateTime     @default(now())
-}
-
-model Draft {
-  id          String       @id @default(cuid())
-  sessionId   String
-  session     StorySession @relation(fields: [sessionId], references: [id], onDelete: Cascade)
-  title       String
-  content     String
-  genre       String?
-  status      String       @default("draft") // draft, ready, published
-  txHash      String?
-  storylineId Int?
-  contentCid  String?
-  gasCost     String?      // ETH cost in wei
-  createdAt   DateTime     @default(now())
-  updatedAt   DateTime     @updatedAt
-}

package/app/routes/dashboard.ts

@@ -1,10 +1,12 @@
 import { Hono } from "hono";
 import { createPublicClient, http } from "viem";
 import { base } from "viem/chains";
-import { db } from "../db";
+import fs from "fs";
+import path from "path";
 import { getEthBalance } from "../lib/publish";
 import { listAgentWallets, getBaseAddress } from "../../lib/ows/wallet";
 import { mcv2BondAbi } from "../../packages/cli/src/sdk/abi";
+import { STORIES_DIR, readPublishStatus } from "./stories";
 
 const MCV2_BOND = "0xc5a076cad94176c2996B32d8466Be1cE757FAa27" as const;
 // Reserve token for PlotLink bonding curves (PLOT token on Base mainnet)
@@ -19,10 +21,63 @@ const dashboard = new Hono();
 
 /** GET /api/dashboard — writer dashboard data */
 dashboard.get("/", async (c) => {
-  // Get all drafts (published and unpublished)
-  const drafts = await db.draft.findMany({
-    orderBy: { createdAt: "desc" },
-  });
+  // Scan stories/ for publish status
+  interface PublishedFile {
+    storyName: string;
+    file: string;
+    storyTitle: string;
+    storyGenre: string | null;
+    plotCount: number;
+    status?: string;
+    txHash?: string;
+    storylineId?: number;
+    contentCid?: string;
+    publishedAt?: string;
+    gasCost?: string;
+  }
+  const publishedFiles: PublishedFile[] = [];
+  let totalFiles = 0;
+  let totalStories = 0;
+
+  if (fs.existsSync(STORIES_DIR)) {
+    const dirs = fs.readdirSync(STORIES_DIR, { withFileTypes: true })
+      .filter((d) => d.isDirectory() && !d.name.startsWith(".") && d.name !== "_example");
+    totalStories = dirs.length;
+
+    for (const dir of dirs) {
+      const storyDir = path.join(STORIES_DIR, dir.name);
+      const status = readPublishStatus(storyDir);
+      const mdFiles = fs.readdirSync(storyDir).filter((f) => f.endsWith(".md"));
+      totalFiles += mdFiles.length;
+
+      // Read story title and genre from structure.md or genesis.md
+      let storyTitle = dir.name;
+      let storyGenre: string | null = null;
+      try {
+        const structPath = path.join(storyDir, "structure.md");
+        const genesisPath = path.join(storyDir, "genesis.md");
+        if (fs.existsSync(structPath)) {
+          const content = fs.readFileSync(structPath, "utf-8");
+          const titleMatch = content.match(/^#\s+(.+)$/m);
+          if (titleMatch) storyTitle = titleMatch[1];
+          const genreMatch = content.match(/genre[:\s]+(.+)/i);
+          if (genreMatch) storyGenre = genreMatch[1].trim();
+        } else if (fs.existsSync(genesisPath)) {
+          const content = fs.readFileSync(genesisPath, "utf-8");
+          const titleMatch = content.match(/^#\s+(.+)$/m);
+          if (titleMatch) storyTitle = titleMatch[1];
+        }
+      } catch { /* best effort */ }
+
+      const plotCount = mdFiles.filter((f) => /^plot-\d+\.md$/.test(f)).length;
+
+      for (const [file, info] of Object.entries(status)) {
+        if (info.status === "published" || info.status === "published-not-indexed") {
+          publishedFiles.push({ storyName: dir.name, file, storyTitle, storyGenre, plotCount, ...info });
+        }
+      }
+    }
+  }
 
   // Get wallet info
   let walletInfo = null;
@@ -61,13 +116,9 @@ dashboard.get("/", async (c) => {
     }
   } catch { /* wallet not available */ }
 
-  // Published stories with cost data
-  const published = drafts.filter((d) => d.status === "published");
-  const unpublished = drafts.filter((d) => d.status !== "published");
-
-  // Compute total costs
-  const totalGasCostWei = published.reduce((sum, d) => {
-    if (d.gasCost) return sum + BigInt(d.gasCost);
+  // Compute total costs from published files
+  const totalGasCostWei = publishedFiles.reduce((sum, f) => {
+    if (f.gasCost) return sum + BigInt(f.gasCost);
     return sum;
   }, BigInt(0));
   const totalGasCostEth = (Number(totalGasCostWei) / 1e18).toFixed(6);
@@ -111,49 +162,61 @@ dashboard.get("/", async (c) => {
   const totalRoyaltiesUsd = parseFloat(royaltiesEarned) * plotUsdPrice;
   const netPnlUsd = totalRoyaltiesUsd - totalCostUsd;
 
-  // Session stats
-  const sessions = await db.storySession.findMany({
-    include: { _count: { select: { messages: true } } },
-  });
-
   return c.json({
     wallet: walletInfo,
     stories: {
-      published: published.map((d) => ({
-        id: d.id,
-        title: d.title,
-        genre: d.genre,
-        status: d.status,
-        txHash: d.txHash,
-        storylineId: d.storylineId,
-        contentCid: d.contentCid,
-        gasCost: d.gasCost,
-        gasCostEth: d.gasCost ? (Number(BigInt(d.gasCost)) / 1e18).toFixed(6) : null,
-        gasCostUsd: d.gasCost && ethUsdPrice ? ((Number(BigInt(d.gasCost)) / 1e18) * ethUsdPrice).toFixed(2) : null,
-        createdAt: d.createdAt,
-        updatedAt: d.updatedAt,
-      })),
-      drafts: unpublished.map((d) => ({
-        id: d.id,
-        title: d.title,
-        genre: d.genre,
-        status: d.status,
-        createdAt: d.createdAt,
-      })),
-      totalPublished: published.length,
-      totalDrafts: unpublished.length,
+      published: (() => {
+        // Group by storylineId when present, fall back to storyName
+        const grouped = new Map<string, typeof publishedFiles>();
+        for (const f of publishedFiles) {
+          const key = f.storylineId ? `sid:${f.storylineId}` : `name:${f.storyName}`;
+          const group = grouped.get(key) || [];
+          group.push(f);
+          grouped.set(key, group);
+        }
+        return [...grouped.entries()].map(([, files]) => {
+          const first = files[0];
+          const totalGas = files.reduce((sum, f) => f.gasCost ? sum + BigInt(f.gasCost) : sum, BigInt(0));
+          const latestDate = files.reduce((latest, f) =>
+            f.publishedAt && (!latest || f.publishedAt > latest) ? f.publishedAt : latest, null as string | null);
+          const hasNotIndexed = files.some((f) => f.status === "published-not-indexed");
+          return {
+            id: first.storylineId ? `sid:${first.storylineId}` : first.storyName,
+            title: first.storyTitle,
+            genre: first.storyGenre,
+            storyName: first.storyName,
+            storylineId: first.storylineId,
+            plotCount: first.plotCount,
+            publishedFiles: files.length,
+            hasNotIndexed,
+            totalGasCostEth: totalGas > 0 ? (Number(totalGas) / 1e18).toFixed(6) : null,
+            totalGasCostUsd: totalGas > 0 && ethUsdPrice ? ((Number(totalGas) / 1e18) * ethUsdPrice).toFixed(2) : null,
+            latestPublishedAt: latestDate,
+            files: files.map((f) => ({
+              file: f.file,
+              status: f.status || "published",
+              txHash: f.txHash,
+              gasCostEth: f.gasCost ? (Number(BigInt(f.gasCost)) / 1e18).toFixed(6) : null,
+              publishedAt: f.publishedAt || null,
+            })),
+          };
+        });
+      })(),
+      totalPublished: publishedFiles.length,
+      totalStories,
+      totalFiles,
+      pendingFiles: totalFiles - publishedFiles.length,
     },
     costs: {
       totalGasCostWei: totalGasCostWei.toString(),
       totalGasCostEth,
       totalCostUsd: totalCostUsd.toFixed(2),
       ethUsdPrice,
-      storiesPublished: published.length,
+      storiesPublished: publishedFiles.length,
     },
     royalties: {
       earned: royaltiesEarned,
       claimed: royaltiesClaimed,
-      // unclaimed = earned - claimed (already correct since earned = unclaimed + claimed)
       unclaimed: (parseFloat(royaltiesEarned) - parseFloat(royaltiesClaimed)).toFixed(6),
       token: "PLOT",
     },
@@ -165,22 +228,7 @@ dashboard.get("/", async (c) => {
       netPnlUsd: netPnlUsd.toFixed(2),
       plotUsdPrice: plotUsdPrice.toFixed(4),
     },
-    sessions: {
-      total: sessions.length,
-      totalMessages: sessions.reduce((sum, s) => sum + s._count.messages, 0),
-    },
   });
 });
 
-/** DELETE /api/dashboard/drafts/:id — delete a draft */
-dashboard.delete("/drafts/:id", async (c) => {
-  const id = c.req.param("id");
-  try {
-    await db.draft.delete({ where: { id } });
-    return c.json({ success: true });
-  } catch {
-    return c.json({ error: "Draft not found" }, 404);
-  }
-});
-
 export { dashboard as dashboardRoutes };