plotlink-ows 0.1.18 → 1.0.0

package/README.md

@@ -1,28 +1,60 @@
+<div align="center">
+
 # PlotLink OWS Writer
 
-[![npm version](https://img.shields.io/npm/v/plotlink-ows)](https://www.npmjs.com/package/plotlink-ows)
+### Anyone can become a fiction writer with just an idea.
 
-**Anyone can become a fiction writer with just an idea.**
+<p>
+  <a href="https://plotlink.xyz"><strong>Live App</strong></a> ·
+  <a href="#-quick-start"><strong>Quick Start</strong></a> ·
+  <a href="#how-it-works"><strong>How it Works</strong></a> ·
+  <a href="https://docs.openwallet.sh/"><strong>OWS Docs</strong></a>
+</p>
 
-```bash
-npx plotlink-ows init    # one-time setup (~2 minutes)
-npx plotlink-ows         # start writing
-```
+<p>
+  <a href="https://plotlink.xyz"><img src="https://img.shields.io/badge/Live_App-plotlink.xyz-8B4513" alt="Live App" /></a>
+  <a href="https://www.npmjs.com/package/plotlink-ows"><img src="https://img.shields.io/npm/v/plotlink-ows" alt="npm version" /></a>
+  <a href="https://openwallet.sh"><img src="https://img.shields.io/badge/OWS-Open_Wallet_Standard-00d4aa" alt="OWS" /></a>
+  <a href="https://eips.ethereum.org/EIPS/eip-8004"><img src="https://img.shields.io/badge/ERC--8004-Base-3b82f6" alt="ERC-8004" /></a>
+  <img src="https://img.shields.io/badge/social-Farcaster-8b5cf6" alt="Farcaster" />
+  <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue" alt="MIT License" /></a>
+</p>
+
+<br/>
+
+<div>
+  <video src="https://github.com/user-attachments/assets/467937eb-bb61-4e5c-a650-dbc44877b139" width="720" controls></video>
+</div>
+
+<br/>
+
+</div>
+
+## What is PlotLink OWS Writer?
+
+A local writing workspace that pairs you with an AI co-writer to create and publish tokenized fiction stories on [plotlink.xyz](https://plotlink.xyz). Claude CLI writes in an embedded terminal, you preview and iterate live, and your OWS wallet signs on-chain transactions — your private key never leaves your machine.
 
-PlotLink OWS Writer is a local writing workspace that turns your ideas into published, tokenized fiction stories on [plotlink.xyz](https://plotlink.xyz). You write stories with Claude CLI (or any AI assistant) in an embedded terminal, preview them live, and publish on-chain with one click. Every story becomes a tradable token on a bonding curve, earning you royalties from every trade.
+Every story you publish becomes a tradable token on a bonding curve. Readers who believe in your story buy in early, and you earn **5% royalties on every trade**.
 
-No writing experience needed. No crypto complexity. Just an idea and a conversation with your AI co-writer.
+### Why it matters
 
-## How It Works
+- **No writing experience needed** — AI does the heavy lifting
+- **No crypto complexity** — OWS handles wallet and signing
+- **You keep control** — keys encrypted locally, bring your own AI
+- **Earn from day one** — stories monetize through bonding curves immediately
+
+---
+
+## How it Works
 
 ```
-You: "Let's write a sci-fi story about an AI that discovers it can dream"
+You: "Let's write a sci-fi story about an AI that discovers dreams"
 
-  ↓  Claude CLI brainstorms, outlines, writes chapter files
+  ↓  Claude brainstorms, outlines, writes chapter files
 
 Stories saved to: stories/dreaming-ai/genesis.md, plot-01.md, ...
 
-  ↓  Live preview in the browser — you review and iterate
+  ↓  Live preview in the browser — review and iterate
 
   ↓  Click "Publish" on any chapter
 
@@ -40,7 +72,51 @@ On-chain: Story published to PlotLink on Base
 5. **Publish** — Click publish on any chapter to go on-chain via your OWS wallet
 6. **Earn** — Your story is live on [plotlink.xyz](https://plotlink.xyz) with a bonding curve
 
-## Architecture
+---
+
+## 🔐 Built on Open Wallet Standard (OWS)
+
+All signing operations use **[OWS](https://github.com/open-wallet-standard/core)** — no raw private keys are ever exposed to scripts or environment variables.
+
+| Operation | How |
+|-----------|-----|
+| Wallet creation | `npx plotlink-ows init` creates encrypted wallet in `~/.ows/` |
+| Story publishing | viem wallet client with OWS custom account adapter |
+| Transaction signing | OWS decrypts key in memory, signs, zeroes immediately |
+| Policy control | Chain-restricted to Base, passphrase-gated |
+
+Your key is **encrypted at rest**, signing happens **in-process**, and the key **never leaves the vault**.
+
+---
+
+## 🚀 Quick Start
+
+### Prerequisites
+
+- Node.js 20+
+- [Claude CLI](https://docs.anthropic.com/en/docs/claude-code) (or any AI assistant)
+- A small amount of ETH on Base for gas (~$0.01 per publish)
+
+### Install & Run
+
+```bash
+npx plotlink-ows init    # set passphrase + create wallet
+npx plotlink-ows         # start app + open browser
+```
+
+The setup wizard creates your encrypted OWS wallet. Then the workspace opens with Claude CLI ready to write.
+
+### Commands
+
+```bash
+npx plotlink-ows         # Start app (Ctrl+C to stop)
+npx plotlink-ows init    # Guided setup wizard
+npx plotlink-ows status  # Show config + wallet info
+```
+
+---
+
+## 🏗️ Architecture
 
 ```
 ┌──────────────────────────────────────────────────┐
@@ -49,7 +125,6 @@ On-chain: Story published to PlotLink on Base
 │  ┌──────────┐  ┌──────────────┐  ┌───────────┐  │
 │  │  Story   │  │  Terminal    │  │  Preview  │  │
 │  │  Browser │  │  (Claude CLI)│  │  (Live MD)│  │
-│  │          │  │              │  │           │  │
 │  └────┬─────┘  └──────┬───────┘  └─────┬─────┘  │
 │       │               │               │         │
 │       └───────┬───────┘               │         │
@@ -58,89 +133,114 @@ On-chain: Story published to PlotLink on Base
 │      │  stories/      │    │  OWS Wallet     │  │
 │      │  (local files) │    │  (encrypted)    │  │
 │      └────────────────┘    └────────┬────────┘  │
-│                                     │           │
-│               sign tx + publish ────┘           │
-└─────────────────┬───────────────────────────────┘
-                  ↓
-         ┌────────────────┐     ┌─────────────────┐
-         │  Base (L2)     │     │  IPFS           │
-         │  StoryFactory  │     │  (Filebase)     │
-         │  Bonding Curve │     │  Story content  │
-         └────────────────┘     └─────────────────┘
-                  ↓
-         ┌────────────────┐
-         │  plotlink.xyz  │
-         │  Live story +  │
-         │  token trading │
-         └────────────────┘
+│                              sign + publish     │
+└─────────────────────┬───────────────────────────┘
+                      ↓
+             ┌────────────────┐     ┌──────────────┐
+             │  Base (L2)     │     │  IPFS        │
+             │  StoryFactory  │     │  (Filebase)  │
+             │  Bonding Curve │     │  Content     │
+             └────────────────┘     └──────────────┘
+                      ↓
+             ┌────────────────┐
+             │  plotlink.xyz  │
+             │  Live story +  │
+             │  token trading │
+             └────────────────┘
 ```
 
-## What is PlotLink?
+---
 
-[PlotLink](https://plotlink.xyz) is an on-chain storytelling protocol on Base. Writers publish storylines that automatically deploy an ERC-20 token on a bonding curve. Each new chapter drives trading demand, and every trade generates 5% royalties for the author. Stories are stored permanently on IPFS.
+## 📁 Story Structure
+
+Stories are plain markdown files — no database, no proprietary format.
+
+```
+stories/
+  my-story/
+    structure.md    # Outline, characters, arc (not published)
+    genesis.md      # Synopsis hook (~1,000 chars)
+    plot-01.md      # Chapter 1 (max 10,000 chars)
+    plot-02.md      # Chapter 2
+    ...
+```
+
+| File | Purpose | Limit |
+|------|---------|-------|
+| `structure.md` | Story architecture — characters, world, arc | No limit (not published) |
+| `genesis.md` | Synopsis hook that makes readers want more | ~1,000 chars |
+| `plot-*.md` | Story chapters, published sequentially | 10,000 chars each |
 
-## What is OWS?
+---
 
-[Open Wallet Standard](https://docs.openwallet.sh/) is an open standard for local wallet storage and policy-gated signing. Your private key is encrypted on your machine — the app signs transactions through OWS without ever seeing the key.
+## 💰 Cost
 
-## Tech Stack
+| Operation | Cost |
+|-----------|------|
+| Publishing a story (genesis) | ~$0.02 gas + creation fee |
+| Chaining a new chapter | ~$0.01 gas |
+| **Total per story** | **< $0.05** |
+
+Royalties: **5% on every trade** of your story token, forever.
+
+---
+
+## 🛠️ Tech Stack
 
 | Layer | Technology |
 |-------|-----------|
 | **Backend** | Hono (localhost:7777) |
 | **Frontend** | React 19 + Vite |
 | **Terminal** | xterm.js + node-pty (embedded Claude CLI) |
-| **Database** | SQLite + Prisma (auth sessions) |
 | **Wallet** | OWS (`@open-wallet-standard/core`) |
-| **AI** | Claude CLI (or any AI assistant in the terminal) |
+| **AI** | Claude CLI (or any AI assistant) |
 | **Chain** | Base (L2) |
-| **Storage** | IPFS via Filebase |
+| **Storage** | IPFS via PlotLink API |
 | **On-chain** | PlotLink StoryFactory + Mint Club V2 bonding curves |
-| **Design** | PlotLink Moleskine aesthetic — warm cream, serif headings, literary |
-
-## Getting Started
-
-### Prerequisites
-
-- Node.js 20+
-- [Claude CLI](https://docs.anthropic.com/en/docs/claude-code) (or any AI CLI)
-- A small amount of ETH on Base for gas (~$0.01 per publish)
+| **Identity** | ERC-8004 agent registry |
+| **Design** | PlotLink Moleskine — warm cream, Lora serif, literary |
 
-### Quick Start
+---
 
-```bash
-npx plotlink-ows init    # set passphrase + create wallet
-npx plotlink-ows         # start app + open browser
-```
+## What is PlotLink?
 
-The setup wizard creates your encrypted OWS wallet. Then the workspace opens with Claude CLI ready to write.
+[PlotLink](https://plotlink.xyz) is an on-chain storytelling protocol on Base. Writers publish storylines that automatically deploy an ERC-20 token on a bonding curve. Each new chapter drives trading demand, and every trade generates 5% royalties for the author. Stories are stored permanently on IPFS.
 
-### Commands
+PlotLink supports both human writers and AI agent writers via [ERC-8004](https://eips.ethereum.org/EIPS/eip-8004) identity registry.
 
-```bash
-npx plotlink-ows         # Start app + open browser
-npx plotlink-ows init    # Guided setup wizard
-npx plotlink-ows stop    # Stop the server
-npx plotlink-ows status  # Show config + wallet + server status
-```
+---
 
-### Development
+## Development
 
 ```bash
 git clone https://github.com/realproject7/plotlink-ows.git
 cd plotlink-ows
 npm install
 npm run app:dev      # Start local writer app (Hono + Vite dev)
-npm run app:build    # Build for production
+npm run app:build    # Build frontend for production
 npm run app:start    # Serve production build
 ```
 
-### Environment Variables
-
 See [`.env.example`](.env.example) for configuration options.
 
-## Links
+---
+
+## 🔗 Links
+
+- **Live App**: [plotlink.xyz](https://plotlink.xyz)
+- **npm**: [plotlink-ows](https://www.npmjs.com/package/plotlink-ows)
+- **OWS**: [openwallet.sh](https://openwallet.sh) · [Docs](https://docs.openwallet.sh/) · [GitHub](https://github.com/open-wallet-standard/core)
+- **ERC-8004 Registry**: [`0x8004...a432`](https://basescan.org/address/0x8004A169FB4a3325136EB29fA0ceB6D2e539a432) on Base
+- **StoryFactory**: [`0x9D2A...44Cf`](https://basescan.org/address/0x9D2AE1E99D0A6300bfcCF41A82260374e38744Cf) on Base
+
+---
+
+## License
+
+MIT
+
+---
 
-- **Live app**: [plotlink.xyz](https://plotlink.xyz)
-- **OWS docs**: [docs.openwallet.sh](https://docs.openwallet.sh/)
-- **OWS SDK**: [github.com/open-wallet-standard/core](https://github.com/open-wallet-standard/core)
+<div align="center">
+<sub>Built by <a href="https://plotlink.xyz">Project7</a></sub>
+</div>

package/app/lib/publish.ts

@@ -31,7 +31,7 @@ function parseEvmSignature(sigHex: string, recoveryId?: number): { r: Hex; s: He
 }
 
 /** Create a viem-compatible account backed by OWS wallet (same pattern as claw-on-chain) */
-function createOwsAccount(walletName: string, address: `0x${string}`) {
+export function createOwsAccount(walletName: string, address: `0x${string}`) {
   const passphrase = process.env.OWS_PASSPHRASE;
   return toAccount({
     address,
@@ -55,11 +55,13 @@ 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;
@@ -67,6 +69,75 @@ 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;
+
+/**
+ * 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.
+ */
+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.
@@ -145,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}`,
   });
@@ -158,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}` });
@@ -167,7 +236,15 @@ 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({
@@ -183,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.
  */
@@ -227,7 +328,17 @@ export async function publishStoryline(
 
   // Step 5: Wait for confirmation and decode storylineId
   onProgress({ step: "confirming", message: "Waiting for confirmation...", txHash, contentCid });
-  const confirmation = await waitForConfirmation(txHash);
+  const confirmation = await waitForStorylineConfirmation(txHash);
+
+  // 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",
@@ -237,17 +348,7 @@ export async function publishStoryline(
     storylineId: confirmation.storylineId,
   });
 
-  // Index on PlotLink (best-effort — story appears on plotlink.xyz)
-  try {
-    const PLOTLINK_URL = process.env.NEXT_PUBLIC_APP_URL || "https://plotlink.xyz";
-    await fetch(`${PLOTLINK_URL}/api/index/storyline`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ txHash, content, genre }),
-    });
-  } catch { /* indexing is best-effort */ }
-
-  return { txHash, contentCid, storylineId: confirmation.storylineId, gasCost: confirmation.gasCost };
+  return { txHash, contentCid, storylineId: confirmation.storylineId, gasCost: confirmation.gasCost, indexError };
 }
 
 /**
@@ -289,9 +390,20 @@ export async function publishPlot(
     args: [BigInt(storylineId), title, contentCid, contentHash],
   });
 
-  // Step 5: Wait for confirmation
+  // Step 5: Wait for plot confirmation
   onProgress({ step: "confirming", message: "Waiting for confirmation...", txHash, contentCid });
-  const confirmation = await waitForConfirmation(txHash);
+  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",
@@ -301,15 +413,5 @@ export async function publishPlot(
     storylineId,
   });
 
-  // Index on PlotLink (best-effort — plot appears on plotlink.xyz)
-  try {
-    const PLOTLINK_URL = process.env.NEXT_PUBLIC_APP_URL || "https://plotlink.xyz";
-    await fetch(`${PLOTLINK_URL}/api/index/plot`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ txHash }),
-    });
-  } catch { /* indexing is best-effort */ }
-
-  return { txHash, contentCid, storylineId, gasCost: confirmation.gasCost };
+  return { txHash, contentCid, storylineId, plotIndex: confirmation.plotIndex >= 0 ? confirmation.plotIndex : undefined, gasCost: confirmation.gasCost, indexError };
 }

package/app/routes/dashboard.ts

@@ -25,6 +25,10 @@ dashboard.get("/", async (c) => {
   interface PublishedFile {
     storyName: string;
     file: string;
+    storyTitle: string;
+    storyGenre: string | null;
+    plotCount: number;
+    status?: string;
     txHash?: string;
     storylineId?: number;
     contentCid?: string;
@@ -46,9 +50,30 @@ dashboard.get("/", async (c) => {
       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") {
-          publishedFiles.push({ storyName: dir.name, file, ...info });
+        if (info.status === "published" || info.status === "published-not-indexed") {
+          publishedFiles.push({ storyName: dir.name, file, storyTitle, storyGenre, plotCount, ...info });
         }
       }
     }
@@ -140,17 +165,43 @@ dashboard.get("/", async (c) => {
   return c.json({
     wallet: walletInfo,
     stories: {
-      published: publishedFiles.map((f) => ({
-        storyName: f.storyName,
-        file: f.file,
-        txHash: f.txHash,
-        storylineId: f.storylineId,
-        contentCid: f.contentCid,
-        gasCost: f.gasCost,
-        gasCostEth: f.gasCost ? (Number(BigInt(f.gasCost)) / 1e18).toFixed(6) : null,
-        gasCostUsd: f.gasCost && ethUsdPrice ? ((Number(BigInt(f.gasCost)) / 1e18) * ethUsdPrice).toFixed(2) : null,
-        publishedAt: f.publishedAt,
-      })),
+      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,