plotlink-ows 0.1.14 → 0.1.18

package/README.md

@@ -9,20 +9,22 @@ npx plotlink-ows init    # one-time setup (~2 minutes)
 npx plotlink-ows         # start writing
 ```
 
-PlotLink OWS Writer is a local AI writing assistant that turns your ideas into published, tokenized fiction stories on [plotlink.xyz](https://plotlink.xyz). You bring the concept — the AI handles the writing, editing, and on-chain publishing. Every story you publish becomes a tradable token on a bonding curve, earning you royalties from every trade.
+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.
 
 No writing experience needed. No crypto complexity. Just an idea and a conversation with your AI co-writer.
 
 ## How It Works
 
 ```
-You: "I want to 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 it can dream"
 
-  ↓  Chat with AI writer — brainstorm, outline, refine
+  ↓  Claude CLI brainstorms, outlines, writes chapter files
 
-AI: Generates a polished 2000-word chapter
+Stories saved to: stories/dreaming-ai/genesis.md, plot-01.md, ...
 
-  ↓  You approve — one click to publish
+  ↓  Live preview in the browser — you review and iterate
+
+  ↓  Click "Publish" on any chapter
 
 On-chain: Story published to PlotLink on Base
           → Token + bonding curve deployed
@@ -31,56 +33,55 @@ On-chain: Story published to PlotLink on Base
 
 ### The Flow
 
-1. **Install & run** — `npm install && npm run app:dev`
-2. **Connect your LLM** — Anthropic, OpenAI, Gemini, or local models (Ollama, LM Studio)
-3. **Get a wallet** — OWS creates an encrypted wallet on your machine (you control the keys)
-4. **Chat** — Discuss story ideas with your AI writer. It brainstorms, outlines, drafts, and refines.
-5. **Publish** — When you're happy, the AI uploads to IPFS and publishes on-chain via your OWS wallet.
-6. **Earn** — Your story is live on [plotlink.xyz](https://plotlink.xyz) with a bonding curve. Early readers who back your story drive the price up, and you earn 5% royalties on every trade.
+1. **Setup** — `npx plotlink-ows init` (passphrase + OWS wallet)
+2. **Start** — `npx plotlink-ows` opens the three-panel workspace
+3. **Write** — Claude CLI runs in the embedded terminal, creating story files
+4. **Preview** — Live markdown preview auto-refreshes as Claude writes
+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
 
 ```
-┌─────────────────────────────────────────────┐
-│         Your Computer (localhost:7777)       │
-│                                             │
-│  ┌──────────┐  ┌──────────┐  ┌───────────┐ │
-│  │ Chat UI  │  │ LLM      │  │ OWS       │ │
-│  │ (React)  │  │ Provider │  │ Wallet    │ │
-│  │          │  │ (yours)  │  │ (local)   │ │
-│  └────┬─────┘  └────┬─────┘  └─────┬─────┘ │
-│       │              │              │       │
-│       └──────┬───────┘              │       │
-│              ↓                      │       │
-│     ┌────────────────┐              │       │
-│     │  AI Writer     │              │       │
-│     │  Agent         ├──────────────┘       │
-│     └───────┬────────┘                      │
-│             │  sign tx + publish            │
-└─────────────┼───────────────────────────────┘
-              ↓
-     ┌────────────────┐     ┌─────────────────┐
-     │  Base (L2)     │     │  IPFS           │
-     │  StoryFactory  │     │  (Filebase)     │
-     │  Bonding Curve │     │  Story content  │
-     └────────────────┘     └─────────────────┘
-              ↓
-     ┌────────────────┐
-     │  plotlink.xyz  │
-     │  Live story +  │
-     │  token trading │
-     └────────────────┘
+┌──────────────────────────────────────────────────┐
+│         Your Computer (localhost:7777)            │
+│                                                  │
+│  ┌──────────┐  ┌──────────────┐  ┌───────────┐  │
+│  │  Story   │  │  Terminal    │  │  Preview  │  │
+│  │  Browser │  │  (Claude CLI)│  │  (Live MD)│  │
+│  │          │  │              │  │           │  │
+│  └────┬─────┘  └──────┬───────┘  └─────┬─────┘  │
+│       │               │               │         │
+│       └───────┬───────┘               │         │
+│               ↓                       │         │
+│      ┌────────────────┐    ┌─────────────────┐  │
+│      │  stories/      │    │  OWS Wallet     │  │
+│      │  (local files) │    │  (encrypted)    │  │
+│      └────────────────┘    └────────┬────────┘  │
+│                                     │           │
+│               sign tx + publish ────┘           │
+└─────────────────┬───────────────────────────────┘
+                  ↓
+         ┌────────────────┐     ┌─────────────────┐
+         │  Base (L2)     │     │  IPFS           │
+         │  StoryFactory  │     │  (Filebase)     │
+         │  Bonding Curve │     │  Story 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.
 
-PlotLink is currently in live testing on Base mainnet with public launch planned for next week.
-
 ## 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 AI agent signs transactions through OWS without ever seeing the key. You set spending limits and chain restrictions via policies.
+[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.
 
 ## Tech Stack
 
@@ -88,9 +89,10 @@ PlotLink is currently in live testing on Base mainnet with public launch planned
 |-------|-----------|
 | **Backend** | Hono (localhost:7777) |
 | **Frontend** | React 19 + Vite |
-| **Database** | SQLite + Prisma (local, embedded) |
+| **Terminal** | xterm.js + node-pty (embedded Claude CLI) |
+| **Database** | SQLite + Prisma (auth sessions) |
 | **Wallet** | OWS (`@open-wallet-standard/core`) |
-| **LLM** | Bring your own — Anthropic, OpenAI, Gemini, Ollama, LM Studio |
+| **AI** | Claude CLI (or any AI assistant in the terminal) |
 | **Chain** | Base (L2) |
 | **Storage** | IPFS via Filebase |
 | **On-chain** | PlotLink StoryFactory + Mint Club V2 bonding curves |
@@ -101,7 +103,7 @@ PlotLink is currently in live testing on Base mainnet with public launch planned
 ### Prerequisites
 
 - Node.js 20+
-- An LLM provider account (Anthropic, OpenAI, or Gemini) or a local model running
+- [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)
 
 ### Quick Start
@@ -111,7 +113,7 @@ 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 Web UI guides you through connecting your LLM (login with Anthropic, OpenAI, or Gemini via OAuth — or use a local model like Ollama).
+The setup wizard creates your encrypted OWS wallet. Then the workspace opens with Claude CLI ready to write.
 
 ### Commands
 
@@ -137,16 +139,6 @@ npm run app:start    # Serve production build
 
 See [`.env.example`](.env.example) for configuration options.
 
-## Screenshots
-
-| LLM Setup | Chat with AI Writer |
-|-----------|-------------------|
-| ![LLM Setup](docs/screenshots/llm-setup.png) | ![Chat](docs/screenshots/chat.png) |
-
-| Publish Flow | Writer Dashboard |
-|-------------|-----------------|
-| ![Publish](docs/screenshots/publish.png) | ![Dashboard](docs/screenshots/dashboard.png) |
-
 ## Links
 
 - **Live app**: [plotlink.xyz](https://plotlink.xyz)

package/app/db.ts

@@ -1,4 +1,4 @@
-import { PrismaClient } from ".prisma/local-client";
+import { PrismaClient } from "../node_modules/.prisma/local-client/index.js";
 
 export const db = new PrismaClient();
 

package/app/lib/paths.ts

@@ -5,7 +5,5 @@ import fs from "fs";
 /** All user state lives in ~/.plotlink-ows/ — survives npx reinstalls */
 export const CONFIG_DIR = path.join(os.homedir(), ".plotlink-ows");
 export const ENV_FILE = path.join(CONFIG_DIR, ".env");
-export const AGENT_CONFIG_FILE = path.join(CONFIG_DIR, "agent.config.json");
-
 // Ensure config dir exists on import
 fs.mkdirSync(CONFIG_DIR, { recursive: true });

package/app/lib/publish.ts

@@ -1,27 +1,54 @@
 /**
  * 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) */
+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 {
@@ -41,20 +68,28 @@ export interface PublishProgress {
 }
 
 /**
- * Upload story content to IPFS via Filebase.
+ * 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 filebaseConfig = getFilebaseConfig();
-  if (!filebaseConfig.accessKey || !filebaseConfig.secretKey) {
-    throw new Error("Filebase not configured. Set FILEBASE_ACCESS_KEY and FILEBASE_SECRET_KEY in .env");
-  }
-
+  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 +120,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],
     }),
@@ -136,7 +171,7 @@ async function waitForConfirmation(txHash: string): Promise<{ storylineId: numbe
   for (const log of receipt.logs) {
     try {
       const decoded = decodeEventLog({
-        abi: STORY_FACTORY_ABI,
+        abi: storyFactoryAbi,
         data: log.data,
         topics: log.topics,
       });
@@ -168,37 +203,113 @@ 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 waitForConfirmation(txHash);
 
-  const txHex = JSON.stringify({
-    to: STORY_FACTORY,
-    data: calldata,
-    value: `0x${creationFee.toString(16)}`,
+  onProgress({
+    step: "done",
+    message: `Published! Storyline #${confirmation.storylineId}`,
+    txHash,
+    contentCid,
+    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 };
+}
+
+/**
+ * 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 confirmation
+  onProgress({ step: "confirming", message: "Waiting for confirmation...", txHash, contentCid });
+  const confirmation = await waitForConfirmation(txHash);
 
   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 };
+  // 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 };
 }

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,38 @@ 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;
+    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;
+
+      for (const [file, info] of Object.entries(status)) {
+        if (info.status === "published") {
+          publishedFiles.push({ storyName: dir.name, file, ...info });
+        }
+      }
+    }
+  }
 
   // Get wallet info
   let walletInfo = null;
@@ -61,13 +91,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 +137,35 @@ 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,
+      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,
       })),
-      totalPublished: published.length,
-      totalDrafts: unpublished.length,
+      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 +177,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 };