plotlink-ows 1.0.33 → 1.2.95

package/app/routes/publish.ts

@@ -1,8 +1,49 @@
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
-import { publishStoryline, publishPlot, getEthBalance, estimatePublishCost, uploadCoverImage, uploadPlotImage, updateStoryline } from "../lib/publish";
+import { publishStoryline, publishPlot, getEthBalance, getCreationFee, estimatePublishCost, uploadCoverImage, uploadPlotImage, updateStoryline } from "../lib/publish";
 import { keccak256, toBytes } from "viem";
-import { listAgentWallets, getBaseAddress } from "../../lib/ows/wallet";
+import { resolveActiveWallet } from "../lib/active-wallet";
+import path from "path";
+import { STORIES_DIR } from "../lib/paths";
+import { readCutsFile } from "../lib/cuts";
+import { checkMarkdownReadiness } from "../lib/cartoon-readiness";
+import { readStoryMeta } from "./stories";
+import { sniffImageType, findStaleAssetPaths } from "../lib/clean-image-sync";
+import { isValidImageAsset } from "../lib/image-asset-validate";
+import { extractOgTitle, leadingTitleSegment } from "../lib/public-title";
+import { canonicalizeGenre, GENRES } from "../../lib/genres";
+
+/**
+ * Resolve a request's genre to a canonical PlotLink value (#412). Returns the
+ * canonical string for a valid/aliased genre, `undefined` for an absent/blank
+ * genre (no metadata change), or an `{ error }` for a non-empty genre that can't
+ * be mapped — so the route fails locally with a clear message instead of letting
+ * PlotLink reject it and leave the public story UNCATEGORIZED.
+ */
+function resolveGenre(input: string | undefined): { genre?: string } | { error: string } {
+  if (!input || !input.trim()) return { genre: undefined };
+  const canonical = canonicalizeGenre(input);
+  if (!canonical) {
+    return { error: `Invalid genre "${input}". Use one of: ${GENRES.join(", ")}.` };
+  }
+  return { genre: canonical };
+}
+
+/**
+ * Validate that an uploaded image's actual magic bytes match its claimed
+ * WebP/JPEG MIME type, so a renamed PNG/text file labeled image/webp cannot be
+ * forwarded to the plotlink backend. Mirrors the byte check the cartoon
+ * clean-image upload uses (#266). Returns a user-facing error string, or null
+ * when the bytes are valid.
+ */
+async function imageBytesError(file: File): Promise<string | null> {
+  const expected = file.type === "image/webp" ? "webp" : "jpeg";
+  const bytes = new Uint8Array(await file.arrayBuffer());
+  if (sniffImageType(bytes) !== expected) {
+    return "File content is not a valid WebP/JPEG image (bytes do not match the image type)";
+  }
+  return null;
+}
 
 const publish = new Hono();
 
@@ -10,52 +51,81 @@ const publish = new Hono();
 publish.get("/preflight", async (c) => {
   try {
     // Check wallet
-    const wallets = listAgentWallets();
-    const wallet = wallets.find((w) => w.name.startsWith("plotlink-writer"));
+    const resolvedWallet = await resolveActiveWallet();
+    const wallet = resolvedWallet.activeWallet;
     if (!wallet) {
-      return c.json({ ready: false, error: "No OWS wallet found" });
+      return c.json({
+        ready: false,
+        error: resolvedWallet.error || "No OWS wallet found",
+        selectionRequired: resolvedWallet.selectionRequired,
+        wallets: resolvedWallet.wallets,
+      });
     }
 
-    const address = getBaseAddress(wallet);
+    const address = wallet.address;
     if (!address) {
       return c.json({ ready: false, error: "No EVM address on wallet" });
     }
 
-    // Check ETH balance against real estimated cost
     const balance = await getEthBalance(address);
+
+    // The MCV2 Bond creation fee is a plain contract read and is the only hard
+    // on-chain cost we can always count on. Read it independently of gas
+    // estimation: a flaky gas estimate must not masquerade as an unreadable-chain
+    // failure. If the fee itself cannot be read, the RPC/contract config is
+    // genuinely broken — that is a real blocker.
+    let creationFee: bigint;
+    try {
+      creationFee = await getCreationFee();
+    } catch {
+      return c.json({
+        ready: false,
+        address,
+        walletName: wallet.name,
+        walletId: wallet.walletId,
+        ethBalance: balance.toString(),
+        error: "Could not read creation fee — check RPC and contract config",
+      });
+    }
+
+    // Gas estimation is best-effort. PlotLink owns Filebase/IPFS server-side and
+    // OWS uploads images/content through the PlotLink API, so there is NO local
+    // Filebase env requirement to gate on (#287). And gas estimation simulates
+    // createStoryline with dummy content the contract can reject — which is why
+    // the real #211 pilot publish succeeded while this estimate failed. So a
+    // failed estimate is a warning, not an absolute publish blocker.
     let totalCost: bigint | null = null;
-    let creationFee = BigInt(0);
-    let estimationFailed = false;
+    let estimateWarning: string | null = null;
     try {
       const dummyCid = "QmDummy";
       const dummyHash = keccak256(toBytes("estimation"));
       const estimate = await estimatePublishCost(address, "Test", dummyCid, dummyHash);
       totalCost = estimate.totalCost;
-      creationFee = estimate.creationFee;
     } catch {
-      estimationFailed = true;
+      estimateWarning =
+        "Could not estimate gas; using the creation fee as the minimum required balance — actual publish may still succeed";
     }
-    // Fail closed: if estimation fails, block publishing
-    const requiredBalance = totalCost ?? BigInt(0);
-    const hasEnoughEth = !estimationFailed && totalCost !== null && balance >= requiredBalance;
 
-    // Check Filebase config
-    const hasFilebase = !!(process.env.FILEBASE_ACCESS_KEY && process.env.FILEBASE_SECRET_KEY);
+    // Require enough ETH for at least the creation fee; when a full gas estimate
+    // is available, require that instead. Never block solely on a missing
+    // estimate — but a genuinely insufficient balance is still a real blocker.
+    const requiredBalance = totalCost ?? creationFee;
+    const hasEnoughEth = balance >= requiredBalance;
 
     return c.json({
-      ready: hasEnoughEth && hasFilebase,
+      ready: hasEnoughEth,
       address,
+      walletName: wallet.name,
+      walletId: wallet.walletId,
       ethBalance: balance.toString(),
       creationFee: creationFee.toString(),
       requiredBalance: requiredBalance.toString(),
       hasEnoughEth,
-      hasFilebase,
-      estimationFailed,
-      error: estimationFailed
-        ? "Could not estimate publish cost — check RPC and contract config"
-        : !hasEnoughEth
-        ? `Insufficient ETH. Need ~${(Number(requiredBalance) / 1e18).toFixed(6)} ETH (creation fee + gas)`
-        : !hasFilebase ? "Filebase not configured" : null,
+      estimationFailed: totalCost === null,
+      estimateWarning,
+      error: !hasEnoughEth
+        ? `Insufficient ETH. Need at least ~${(Number(requiredBalance) / 1e18).toFixed(6)} ETH (creation fee${totalCost !== null ? " + gas" : ""})`
+        : null,
     });
   } catch (err: unknown) {
     const message = err instanceof Error ? err.message : "Preflight check failed";
@@ -63,6 +133,58 @@ publish.get("/preflight", async (c) => {
   }
 });
 
+/**
+ * GET /api/publish/public-title — read the INDEXED public title from PlotLink
+ * after a publish (#379). There is no public JSON read endpoint, so this fetches
+ * the rendered public page server-side (no CORS) and extracts its og:title:
+ *   - genesis/storyline (`/story/<id>`)      → { storylineTitle }
+ *   - plot (`/story/<id>/<plotIndex>`)       → { plotTitle } (leading title segment)
+ * `fetched:false` when the page is unreachable / has no title, so the caller
+ * treats it as inconclusive rather than a false pass. The client then runs the
+ * pure title verifier on the result.
+ */
+publish.get("/public-title", async (c) => {
+  const storylineId = c.req.query("storylineId");
+  const plotIndex = c.req.query("plotIndex");
+  if (!storylineId || !/^\d+$/.test(storylineId)) {
+    return c.json({ ok: false, error: "Valid storylineId required" }, 400);
+  }
+  const isPlot = plotIndex != null && plotIndex !== "" && /^\d+$/.test(plotIndex);
+  const PLOTLINK_URL = process.env.NEXT_PUBLIC_APP_URL || "https://plotlink.xyz";
+  const url = isPlot
+    ? `${PLOTLINK_URL}/story/${storylineId}/${plotIndex}`
+    : `${PLOTLINK_URL}/story/${storylineId}`;
+  const storylineUrl = `${PLOTLINK_URL}/story/${storylineId}`;
+
+  try {
+    if (!isPlot) {
+      const res = await fetch(url);
+      if (!res.ok) return c.json({ ok: true, fetched: false });
+      const og = extractOgTitle(await res.text());
+      if (!og) return c.json({ ok: true, fetched: false });
+      return c.json({ ok: true, fetched: true, storylineTitle: og });
+    }
+
+    const plotRes = await fetch(url);
+    if (!plotRes.ok) return c.json({ ok: true, fetched: false });
+    const plotOg = extractOgTitle(await plotRes.text());
+    if (!plotOg) return c.json({ ok: true, fetched: false });
+    let storylineOg: string | null = null;
+    try {
+      const storylineRes = await fetch(storylineUrl);
+      storylineOg = storylineRes.ok ? extractOgTitle(await storylineRes.text()) : null;
+    } catch {
+      // Best-effort read only. If the storyline page fetch rejects, keep the
+      // successful plot-page title and fall back to last-segment stripping.
+      storylineOg = null;
+    }
+    return c.json({ ok: true, fetched: true, plotTitle: leadingTitleSegment(plotOg, storylineOg) });
+  } catch {
+    // Network/parse failure → inconclusive; never block on a flaky read.
+    return c.json({ ok: true, fetched: false });
+  }
+});
+
 /** POST /api/publish/file — publish a story file on-chain (streams progress) */
 publish.post("/file", async (c) => {
   const body = await c.req.json<{
@@ -74,12 +196,22 @@ publish.post("/file", async (c) => {
     language?: string;
     isNsfw?: boolean;
     storylineId?: number;
+    contentType?: string;
   }>();
 
   if (!body.title || !body.content) {
     return c.json({ error: "title and content required" }, 400);
   }
 
+  // Canonicalize the genre up-front (#412) so it's the canonical PlotLink value in
+  // the content metadata, and a non-mappable genre fails here with a clear message
+  // instead of after the on-chain publish.
+  const genreResult = resolveGenre(body.genre);
+  if ("error" in genreResult) {
+    return c.json({ error: genreResult.error }, 400);
+  }
+  const canonicalGenre = genreResult.genre;
+
   // Enforce character limits
   const isGenesis = body.fileName === "genesis.md";
   const isPlot = /^plot-\d+\.md$/.test(body.fileName);
@@ -90,16 +222,68 @@ publish.post("/file", async (c) => {
     }, 400);
   }
 
-  // Get wallet
-  let wallets;
+  // Cartoon plot readiness — block invalid/incomplete publish markdown.
+  // Derive cartoon status from server-side .story.json metadata (NOT the
+  // request body) so a direct API caller cannot bypass by omitting/faking
+  // contentType.
+  if (isPlot) {
+    const storyDir = path.join(STORIES_DIR, body.storyName);
+    const isCartoon = readStoryMeta(storyDir).contentType === "cartoon";
+    if (isCartoon) {
+      const plotFile = body.fileName.replace(/\.md$/, "");
+      let cutsFile;
+      try {
+        cutsFile = readCutsFile(storyDir, plotFile);
+      } catch (err) {
+        return c.json({ error: `Cannot publish: ${(err as Error).message}` }, 400);
+      }
+      if (!cutsFile) {
+        return c.json({ error: `Cannot publish: ${plotFile}.cuts.json not found. Generate cuts and upload final images first.` }, 400);
+      }
+
+      // Block on stale recorded asset paths — a cut whose cleanImagePath /
+      // finalImagePath points to a missing/invalid local file is not actually
+      // ready, and the generic markdown issues would obscure why (#302). Skip
+      // already-uploaded cuts: their content is on IPFS (uploadedUrl), so a
+      // missing LOCAL asset must not block re-publish.
+      const stale = findStaleAssetPaths(
+        cutsFile.cuts,
+        (rel) => isValidImageAsset(storyDir, rel),
+      ).filter((issue) => {
+        const cut = cutsFile.cuts.find((ct) => ct.id === issue.cutId);
+        return !cut?.uploadedUrl;
+      });
+      if (stale.length > 0) {
+        const messages = stale.map((s) => s.message);
+        return c.json(
+          { error: `Cartoon plot not ready to publish: ${messages.join("; ")}`, issues: messages },
+          400,
+        );
+      }
+
+      const { ready, issues } = checkMarkdownReadiness(body.content, cutsFile.cuts);
+      if (!ready) {
+        return c.json({ error: `Cartoon plot not ready to publish: ${issues.join("; ")}`, issues }, 400);
+      }
+    }
+  }
+
+  // Get active wallet
+  let wallet;
   try {
-    wallets = listAgentWallets();
+    const resolvedWallet = await resolveActiveWallet();
+    wallet = resolvedWallet.activeWallet;
+    if (!wallet) {
+      return c.json({
+        error: resolvedWallet.error || "No OWS wallet",
+        selectionRequired: resolvedWallet.selectionRequired,
+        wallets: resolvedWallet.wallets,
+      }, 400);
+    }
   } catch (err) {
-    console.error("[publish/file] listAgentWallets error:", err);
+    console.error("[publish/file] resolveActiveWallet error:", err);
     return c.json({ error: `OWS wallet error: ${err instanceof Error ? err.message : String(err)}` }, 500);
   }
-  const wallet = wallets.find((w) => w.name.startsWith("plotlink-writer"));
-  if (!wallet) return c.json({ error: "No OWS wallet" }, 400);
 
   console.log("[publish/file] Starting publish for", body.storyName, body.fileName, "wallet:", wallet.name);
 
@@ -116,7 +300,7 @@ publish.post("/file", async (c) => {
           body.storylineId,
           body.title,
           body.content,
-          body.genre,
+          canonicalGenre,
           async (progress) => {
             await stream.writeSSE({ data: JSON.stringify(progress) });
           },
@@ -128,12 +312,13 @@ publish.post("/file", async (c) => {
           wallet.name,
           body.title,
           body.content,
-          body.genre,
+          canonicalGenre,
           async (progress) => {
             await stream.writeSSE({ data: JSON.stringify(progress) });
           },
           body.language,
           body.isNsfw,
+          body.contentType,
         );
       }
 
@@ -199,11 +384,17 @@ publish.post("/retry-index", async (c) => {
 /** POST /api/publish/upload-cover — upload cover image with wallet signature */
 publish.post("/upload-cover", async (c) => {
   try {
-    const wallets = listAgentWallets();
-    const wallet = wallets.find((w) => w.name.startsWith("plotlink-writer"));
-    if (!wallet) return c.json({ error: "No OWS wallet" }, 400);
+    const resolvedWallet = await resolveActiveWallet();
+    const wallet = resolvedWallet.activeWallet;
+    if (!wallet) {
+      return c.json({
+        error: resolvedWallet.error || "No OWS wallet",
+        selectionRequired: resolvedWallet.selectionRequired,
+        wallets: resolvedWallet.wallets,
+      }, 400);
+    }
 
-    const address = getBaseAddress(wallet);
+    const address = wallet.address;
     if (!address) return c.json({ error: "No EVM address on wallet" }, 400);
 
     const formData = await c.req.formData();
@@ -223,6 +414,9 @@ publish.post("/upload-cover", async (c) => {
       return c.json({ error: "Only WebP and JPEG images are accepted" }, 400);
     }
 
+    const bytesError = await imageBytesError(file);
+    if (bytesError) return c.json({ error: bytesError }, 400);
+
     const cid = await uploadCoverImage(wallet.name, address as `0x${string}`, file);
     return c.json({ cid });
   } catch (err: unknown) {
@@ -234,11 +428,17 @@ publish.post("/upload-cover", async (c) => {
 /** POST /api/publish/upload-plot-image — upload plot illustration with wallet signature */
 publish.post("/upload-plot-image", async (c) => {
   try {
-    const wallets = listAgentWallets();
-    const wallet = wallets.find((w) => w.name.startsWith("plotlink-writer"));
-    if (!wallet) return c.json({ error: "No OWS wallet" }, 400);
+    const resolvedWallet = await resolveActiveWallet();
+    const wallet = resolvedWallet.activeWallet;
+    if (!wallet) {
+      return c.json({
+        error: resolvedWallet.error || "No OWS wallet",
+        selectionRequired: resolvedWallet.selectionRequired,
+        wallets: resolvedWallet.wallets,
+      }, 400);
+    }
 
-    const address = getBaseAddress(wallet);
+    const address = wallet.address;
     if (!address) return c.json({ error: "No EVM address on wallet" }, 400);
 
     const formData = await c.req.formData();
@@ -269,11 +469,17 @@ publish.post("/upload-plot-image", async (c) => {
 /** POST /api/publish/update-storyline — update storyline metadata with wallet signature */
 publish.post("/update-storyline", async (c) => {
   try {
-    const wallets = listAgentWallets();
-    const wallet = wallets.find((w) => w.name.startsWith("plotlink-writer"));
-    if (!wallet) return c.json({ error: "No OWS wallet" }, 400);
+    const resolvedWallet = await resolveActiveWallet();
+    const wallet = resolvedWallet.activeWallet;
+    if (!wallet) {
+      return c.json({
+        error: resolvedWallet.error || "No OWS wallet",
+        selectionRequired: resolvedWallet.selectionRequired,
+        wallets: resolvedWallet.wallets,
+      }, 400);
+    }
 
-    const address = getBaseAddress(wallet);
+    const address = wallet.address;
     if (!address) return c.json({ error: "No EVM address on wallet" }, 400);
 
     const body = await c.req.json<{
@@ -288,13 +494,21 @@ publish.post("/update-storyline", async (c) => {
       return c.json({ error: "storylineId required" }, 400);
     }
 
+    // Canonicalize the genre before the signed on-chain metadata update so a
+    // natural label (e.g. "Sci-Fi") becomes "Science Fiction" rather than being
+    // rejected by PlotLink and leaving the public story UNCATEGORIZED (#412).
+    const genreResult = resolveGenre(body.genre);
+    if ("error" in genreResult) {
+      return c.json({ error: genreResult.error }, 400);
+    }
+
     await updateStoryline(
       wallet.name,
       address as `0x${string}`,
       body.storylineId,
       {
         coverCid: body.coverCid,
-        genre: body.genre,
+        genre: genreResult.genre,
         language: body.language,
         isNsfw: body.isNsfw,
       },

package/app/routes/settings.ts

@@ -2,28 +2,66 @@ import { Hono } from "hono";
 import { createPublicClient, createWalletClient, http, decodeEventLog } from "viem";
 import { base } from "viem/chains";
 import { erc8004Abi } from "../../packages/cli/src/sdk/abi";
-import { listAgentWallets, getBaseAddress } from "../../lib/ows/wallet";
+import { resolveActiveWallet } from "../lib/active-wallet";
 import { createOwsAccount } from "../lib/publish";
-import { db } from "../db";
-import {
-  signMessage as owsSignMsg,
-} from "@open-wallet-standard/core";
 import { CONFIG_DIR } from "../lib/paths";
 import fs from "fs";
 import path from "path";
 
 const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+type Config = Record<string, unknown>;
 
-function readConfig(): Record<string, unknown> {
+function readConfig(): Config {
   try { return JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8")); } catch { return {}; }
 }
 
-function writeConfig(updates: Record<string, unknown>) {
+function writeConfig(updates: Config) {
   const config = readConfig();
   Object.assign(config, updates);
   fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
 }
 
+function normalizeAddress(address: unknown): string | null {
+  return typeof address === "string" && /^0x[a-fA-F0-9]{40}$/.test(address)
+    ? address.toLowerCase()
+    : null;
+}
+
+function getWalletAgentConfig(
+  config: Config,
+  wallet: { walletId?: string; name: string; address: string },
+  selectableWalletCount: number,
+): Config | null {
+  if (!config.agentId) return null;
+
+  const cachedAddress = normalizeAddress(config.agentWalletAddress);
+  const activeAddress = normalizeAddress(wallet.address);
+  if (cachedAddress && activeAddress) {
+    return cachedAddress === activeAddress ? config : null;
+  }
+
+  if (typeof config.agentWalletId === "string" && wallet.walletId) {
+    return config.agentWalletId === wallet.walletId ? config : null;
+  }
+
+  if (typeof config.agentWalletName === "string") {
+    return config.agentWalletName === wallet.name ? config : null;
+  }
+
+  // Backwards compatibility for pre-#196 installs: an unscoped cache can only
+  // be trusted when there is no wallet-switching ambiguity.
+  return selectableWalletCount <= 1 ? config : null;
+}
+
+function walletAgentConfig(wallet: { walletId?: string; name: string; address: string }, updates: Config): Config {
+  return {
+    ...updates,
+    agentWalletAddress: wallet.address.toLowerCase(),
+    agentWalletName: wallet.name,
+    ...(wallet.walletId ? { agentWalletId: wallet.walletId } : {}),
+  };
+}
+
 const ERC_8004 = "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432" as const;
 const rpcUrl = process.env.NEXT_PUBLIC_RPC_URL || "https://mainnet.base.org";
 
@@ -43,33 +81,37 @@ settings.post("/generate-binding", async (c) => {
   }
 
   try {
-    const wallets = listAgentWallets();
-    const wallet = wallets.find((w) => w.name.startsWith("plotlink-writer"));
-    if (!wallet) return c.json({ error: "No OWS wallet found. Create one in Wallet settings first." }, 400);
+    const resolvedWallet = await resolveActiveWallet();
+    const wallet = resolvedWallet.activeWallet;
+    if (!wallet) {
+      return c.json({
+        error: resolvedWallet.error || "No OWS wallet found. Create one in Wallet settings first.",
+        selectionRequired: resolvedWallet.selectionRequired,
+        wallets: resolvedWallet.wallets,
+      }, 400);
+    }
 
-    const owsWallet = getBaseAddress(wallet);
+    const owsWallet = wallet.address;
     if (!owsWallet) return c.json({ error: "No EVM address on wallet" }, 400);
 
     const message = `I authorize ${body.humanWallet} as my PlotLink owner. Wallet: ${owsWallet}`;
-    const passphrase = process.env.OWS_PASSPHRASE;
-
-    const result = owsSignMsg(wallet.name, "eip155:8453", message, passphrase);
-    const signature = result.signature.startsWith("0x") ? result.signature : `0x${result.signature}`;
+    const account = createOwsAccount(wallet.name, owsWallet as `0x${string}`);
+    const signature = await account.signMessage({ message });
 
     // Include agent data from config.json if available
-    const config = readConfig();
+    const config = getWalletAgentConfig(readConfig(), wallet, resolvedWallet.wallets.filter((w) => w.address).length);
 
     return c.json({
       message,
       signature,
       owsWallet,
-      agentId: config.agentId ? Number(config.agentId) : undefined,
-      agentName: (config.agentName as string) || undefined,
-      agentDescription: (config.agentDescription as string) || undefined,
-      agentGenre: (config.agentGenre as string) || undefined,
-      agentLlmModel: (config.agentLlmModel as string) || undefined,
-      agentRegisteredBy: (config.agentRegisteredBy as string) || undefined,
-      agentRegisteredAt: (config.agentRegisteredAt as string) || undefined,
+      agentId: config?.agentId ? Number(config.agentId) : undefined,
+      agentName: (config?.agentName as string) || undefined,
+      agentDescription: (config?.agentDescription as string) || undefined,
+      agentGenre: (config?.agentGenre as string) || undefined,
+      agentLlmModel: (config?.agentLlmModel as string) || undefined,
+      agentRegisteredBy: (config?.agentRegisteredBy as string) || undefined,
+      agentRegisteredAt: (config?.agentRegisteredAt as string) || undefined,
     });
   } catch (err: unknown) {
     const msg = err instanceof Error ? err.message : "Failed to generate binding proof";
@@ -89,11 +131,17 @@ settings.post("/register-agent", async (c) => {
   }
 
   try {
-    const wallets = listAgentWallets();
-    const wallet = wallets.find((w) => w.name.startsWith("plotlink-writer"));
-    if (!wallet) return c.json({ error: "No OWS wallet found. Create one in Wallet settings first." }, 400);
+    const resolvedWallet = await resolveActiveWallet();
+    const wallet = resolvedWallet.activeWallet;
+    if (!wallet) {
+      return c.json({
+        error: resolvedWallet.error || "No OWS wallet found. Create one in Wallet settings first.",
+        selectionRequired: resolvedWallet.selectionRequired,
+        wallets: resolvedWallet.wallets,
+      }, 400);
+    }
 
-    const owsAddress = getBaseAddress(wallet);
+    const owsAddress = wallet.address;
     if (!owsAddress) return c.json({ error: "No EVM address on wallet" }, 400);
 
     // Check if already registered
@@ -160,7 +208,7 @@ settings.post("/register-agent", async (c) => {
     }
 
     // Cache full tokenURI data in config.json (survives npx reinstalls, no Prisma dependency)
-    writeConfig({
+    writeConfig(walletAgentConfig(wallet, {
       agentId,
       agentName: body.name.trim(),
       agentDescription: body.description.trim(),
@@ -168,7 +216,7 @@ settings.post("/register-agent", async (c) => {
       agentLlmModel: "Claude",
       agentRegisteredBy: "plotlink-ows",
       agentRegisteredAt: registeredAt,
-    });
+    }));
 
     return c.json({
       agentId,
@@ -184,16 +232,23 @@ settings.post("/register-agent", async (c) => {
 /** GET /api/settings/link-status — check if OWS wallet is registered on ERC-8004 */
 settings.get("/link-status", async (c) => {
   try {
-    const wallets = listAgentWallets();
-    const wallet = wallets.find((w) => w.name.startsWith("plotlink-writer"));
-    if (!wallet) return c.json({ linked: false, error: "No wallet" });
+    const resolvedWallet = await resolveActiveWallet();
+    const wallet = resolvedWallet.activeWallet;
+    if (!wallet) {
+      return c.json({
+        linked: false,
+        error: resolvedWallet.error || "No wallet",
+        selectionRequired: resolvedWallet.selectionRequired,
+        wallets: resolvedWallet.wallets,
+      });
+    }
 
-    const address = getBaseAddress(wallet);
+    const address = wallet.address;
     if (!address) return c.json({ linked: false, error: "No EVM address" });
 
     // Check config.json cache first (survives npx reinstalls + RPC rate limits)
-    const config = readConfig();
-    if (config.agentId) {
+    const config = getWalletAgentConfig(readConfig(), wallet, resolvedWallet.wallets.filter((w) => w.address).length);
+    if (config?.agentId) {
       return c.json({ linked: true, agentId: Number(config.agentId), owsWallet: address });
     }
 
@@ -207,7 +262,7 @@ settings.get("/link-status", async (c) => {
       }) as bigint;
 
       if (agentId > 0n) {
-        writeConfig({ agentId: Number(agentId) });
+        writeConfig(walletAgentConfig(wallet, { agentId: Number(agentId) }));
         return c.json({ linked: true, agentId: Number(agentId), owsWallet: address });
       }
     } catch { /* agentIdByWallet may revert if not bound */ }
@@ -235,7 +290,7 @@ settings.get("/link-status", async (c) => {
         } catch { /* ERC-721 Enumerable not supported */ }
 
         if (agentId !== undefined) {
-          writeConfig({ agentId });
+          writeConfig(walletAgentConfig(wallet, { agentId }));
         }
         return c.json({ linked: true, agentId, owsWallet: address });
       }