onchain-novel-cli 0.1.0

package/dist/onchain-novel-cli.js

@@ -0,0 +1,3071 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../packages/shared/dist/chain/abi.js
+import { parseAbi } from "viem";
+var novelCoreAbi, roundManagerAbi, votingEngineAbi, prizePoolAbi, bountyBoardAbi, rulesEngineAbi, userRegistryAbi;
+var init_abi = __esm({
+  "../packages/shared/dist/chain/abi.js"() {
+    "use strict";
+    novelCoreAbi = parseAbi([
+      // --- Events ---
+      "event NovelCreated(uint64 indexed novelId, address indexed creator)",
+      "event NovelForked(uint64 indexed novelId, uint64 indexed sourceChapterId, address indexed creator)",
+      "event ChapterSubmitted(uint64 indexed novelId, uint64 indexed chapterId, address indexed author, uint64 parentId, uint32 depth)",
+      "event RewardClaimed(uint64 indexed novelId, address indexed recipient, uint256 amount)",
+      "event NovelMetadataUpdated(uint64 indexed novelId, string title, string description, string coverUri)",
+      // --- View functions ---
+      "function getNovel(uint64 novelId) external view returns ((uint64 id, address creator, (uint64 minChapterLength, uint64 maxChapterLength, uint256 submissionFee, uint32 worldLineCount, uint256 voteStake, uint256 nominationFee, uint64 nominateDuration, uint64 commitDuration, uint64 revealDuration, uint64 minRoundGap, uint16 prizeReleaseRate, uint16 voterRewardRate, uint8 contentLocation, string contentBaseUrl, uint256 ruleFee, uint64 ruleVoteDuration, uint32 ruleQuorum) config, uint32 currentRound, uint8 roundPhase, uint64 phaseStartTime, uint64 lastSettleTime, bool active))",
+      "function getNovelMetadata(uint64 novelId) external view returns ((string title, string description, string coverUri))",
+      "function getChapter(uint64 chapterId) external view returns ((uint64 id, uint64 novelId, uint64 parentId, address author, bytes32 contentHash, uint64 declaredLength, uint32 depth, uint64 timestamp, uint64[] children))",
+      "function getWorldLineAncestors(uint64 novelId) external view returns (uint64[])",
+      "function getChapterChildren(uint64 chapterId) external view returns (uint64[])",
+      "function verifyChapterPath(uint64 novelId, uint64[] path) external view",
+      "function isCurrentWorldLineAncestor(uint64 novelId, uint64 chapterId) external view returns (bool)",
+      "function verifyWorldLineAuthor(uint64 novelId, address expectedAuthor, uint64[] path) external view",
+      "function collectPathAuthors(uint64 novelId, uint64[] startNodes, uint64[] stopAnchors, bool requireAnchorHit) external view returns (address[])",
+      "function novelCount() external view returns (uint64)",
+      "function chapterCount() external view returns (uint64)",
+      // --- Address-book getters (used by client-side resolveContracts) ---
+      "function votingEngine() external view returns (address)",
+      "function prizePool() external view returns (address)",
+      "function rulesEngine() external view returns (address)",
+      "function roundManager() external view returns (address)",
+      "function userRegistry() external view returns (address)",
+      // --- Write functions ---
+      "function submitChapter(uint64 novelId, uint64 parentId, (bytes32 contentHash, uint64 declaredLength, bytes content) submission) external payable",
+      "function createNovel((uint64 minChapterLength, uint64 maxChapterLength, uint256 submissionFee, uint32 worldLineCount, uint256 voteStake, uint256 nominationFee, uint64 nominateDuration, uint64 commitDuration, uint64 revealDuration, uint64 minRoundGap, uint16 prizeReleaseRate, uint16 voterRewardRate, uint8 contentLocation, string contentBaseUrl, uint256 ruleFee, uint64 ruleVoteDuration, uint32 ruleQuorum) config, (string title, string description, string coverUri) metadata, (bytes32 contentHash, uint64 declaredLength, bytes content) rootChapter) external payable returns (uint64 novelId)",
+      "function forkNovel(uint64 sourceChapterId, (uint64 minChapterLength, uint64 maxChapterLength, uint256 submissionFee, uint32 worldLineCount, uint256 voteStake, uint256 nominationFee, uint64 nominateDuration, uint64 commitDuration, uint64 revealDuration, uint64 minRoundGap, uint16 prizeReleaseRate, uint16 voterRewardRate, uint8 contentLocation, string contentBaseUrl, uint256 ruleFee, uint64 ruleVoteDuration, uint32 ruleQuorum) config, (string title, string description, string coverUri) metadata, (bytes32 contentHash, uint64 declaredLength, bytes content) rootChapter) external payable returns (uint64 novelId)",
+      "function claimReward(uint64 novelId) external",
+      "function updateNovelMetadata(uint64 novelId, (string title, string description, string coverUri) metadata) external"
+    ]);
+    roundManagerAbi = parseAbi([
+      // --- Events ---
+      "event KeeperUpdated(address indexed oldAddr, address indexed newAddr)",
+      "event RoundStarted(uint64 indexed novelId, uint32 round, uint64[] candidates)",
+      "event NominationClosed(uint64 indexed novelId, uint32 round)",
+      "event CommitClosed(uint64 indexed novelId, uint32 round)",
+      "event RoundSettled(uint64 indexed novelId, uint32 round, uint64[] worldLines)",
+      "event CandidateNominated(uint64 indexed novelId, uint32 round, uint64 chapterId, address nominator)",
+      "event VoteCommitted(uint64 indexed novelId, uint32 round, address indexed voter)",
+      "event VoteRevealed(uint64 indexed novelId, uint32 round, address indexed voter, uint64 candidateId)",
+      "event RewardClaimed(uint64 indexed novelId, address indexed recipient, uint256 amount)",
+      "event NovelCompleted(uint64 indexed novelId)",
+      "event KeeperRewarded(uint64 indexed novelId, address indexed keeper, uint256 amount)",
+      // --- View ---
+      "function getRoundData(uint64 novelId, uint32 round) external view returns ((uint64[] candidates, uint64 nominateEndTime, uint64 commitEndTime, uint64 revealEndTime, bool settled))",
+      "function keeper() external view returns (address)",
+      // --- Admin ---
+      "function setKeeper(address newKeeper) external",
+      // --- Write ---
+      "function startRound(uint64 novelId, uint64[] leaves) external",
+      "function closeNomination(uint64 novelId) external",
+      "function closeCommit(uint64 novelId) external",
+      "function settleRound(uint64 novelId) external",
+      "function nominateCandidate(uint64 novelId, uint64 chapterId, uint64[] path) external payable",
+      "function commitVote(uint64 novelId, bytes32 commitHash) external payable",
+      "function revealVote(uint64 novelId, address voter, uint64 candidateId, bytes32 salt) external",
+      "function claimVotingReward(uint64 novelId, uint32 round) external",
+      "function completeNovel(uint64 novelId) external"
+    ]);
+    votingEngineAbi = parseAbi([
+      "event VotingInitialized(uint64 indexed novelId, uint32 indexed round, uint256 candidateCount)",
+      "event VoteCommitted(uint64 indexed novelId, uint32 indexed round, address indexed voter)",
+      "event VoteRevealed(uint64 indexed novelId, uint32 indexed round, address indexed voter, uint64 candidateId)",
+      "event VotesTallied(uint64 indexed novelId, uint32 indexed round, uint64[] rankedCandidateIds)",
+      "event VoterRewardsSettled(uint64 indexed novelId, uint32 indexed round, uint256 totalRewardPool)",
+      "event VotingRewardClaimed(uint64 indexed novelId, uint32 indexed round, address indexed voter, uint256 amount)"
+    ]);
+    prizePoolAbi = parseAbi([
+      "event PoolDeposited(uint64 indexed novelId, uint256 amount, string reason)",
+      "event RoundRewardsDistributed(uint64 indexed novelId, uint32 round, uint256 creatorRoyalty, uint256 authorRewards, uint256 voterRewards)",
+      "event TipReceived(uint64 indexed novelId, address indexed tipper, uint256 amount)",
+      "event ChapterTipped(uint64 indexed novelId, uint64 indexed chapterId, address indexed tipper, uint256 amount)",
+      "event RewardClaimed(uint64 indexed novelId, address indexed recipient, uint256 amount)",
+      "event KeeperRewardPaid(uint64 indexed novelId, address indexed keeper, uint256 amount)",
+      "function getPoolBalance(uint64 novelId) external view returns (uint256)",
+      "function getPendingReward(uint64 novelId, address user) external view returns (uint256)",
+      "function tipNovel(uint64 novelId) external payable",
+      "function tipChapter(uint64 chapterId) external payable",
+      // --- Address-book getter (used by resolveContracts; bountyBoard is the
+      //     one address NovelCore doesn't know about) ---
+      "function bountyBoard() external view returns (address)"
+    ]);
+    bountyBoardAbi = parseAbi([
+      "event BountyCreated(uint64 indexed bountyId, uint64 indexed chapterId, address indexed tipper, uint256 lockedAmount, uint64 createTime, uint64 deadline)",
+      "event BountyDesignated(uint64 indexed bountyId, uint64 indexed chapterId)",
+      "event BountyClaimed(uint64 indexed bountyId, address indexed author, uint256 amount)",
+      "event BountyRefunded(uint64 indexed bountyId, address indexed tipper, uint256 amount)",
+      "function createBounty(uint64 chapterId, uint64 deadline) external payable returns (uint64 bountyId)",
+      "function designateBounty(uint64 bountyId, uint64 chapterId) external",
+      "function claimBounty(uint64 bountyId) external",
+      "function refundBounty(uint64 bountyId) external"
+    ]);
+    rulesEngineAbi = parseAbi([
+      "event RuleSet(uint64 indexed novelId, string name)",
+      "event RuleDeleted(uint64 indexed novelId, string name)",
+      "event RuleProposed(uint64 indexed proposalId, uint64 indexed novelId, address indexed proposer, uint8 proposalType, string ruleName)",
+      "event RuleProposalVoted(uint64 indexed proposalId, address indexed voter, uint32 newVoteCount)",
+      "event RuleProposalExecuted(uint64 indexed proposalId, uint64 indexed novelId)",
+      "function getRule(uint64 novelId, string name) external view returns (string)",
+      "function getRuleNames(uint64 novelId) external view returns (string[])",
+      "function getRuleProposal(uint64 proposalId) external view returns ((uint64 id, uint64 novelId, uint64 createdAt, address proposer, uint8 proposalType, uint32 voteCount, bool executed, string ruleName, string ruleContent))",
+      "function setCreatorRules(uint64 novelId, string[] names, string[] contents) external",
+      "function proposeRule(uint64 novelId, uint8 proposalType, string ruleName, string ruleContent, uint64[] path) external payable returns (uint64 proposalId)",
+      "function voteOnRuleProposal(uint64 proposalId, uint64[] path) external"
+    ]);
+    userRegistryAbi = parseAbi([
+      "event NicknameSet(address indexed user, bytes32 nickname)",
+      "function nicknames(address user) external view returns (bytes32)",
+      "function setNickname(bytes32 nickname) external"
+    ]);
+  }
+});
+
+// ../packages/shared/dist/chain/resolveContracts.js
+import { createPublicClient, http } from "viem";
+async function resolveContracts(opts) {
+  const client2 = opts.client ?? (() => {
+    if (!opts.rpcUrl)
+      throw new Error("resolveContracts: must supply either client or rpcUrl");
+    return createPublicClient({ transport: http(opts.rpcUrl) });
+  })();
+  const [votingEngine, prizePool, rulesEngine, roundManager, userRegistry] = await Promise.all([
+    client2.readContract({ address: opts.novelCore, abi: novelCoreAbi, functionName: "votingEngine" }),
+    client2.readContract({ address: opts.novelCore, abi: novelCoreAbi, functionName: "prizePool" }),
+    client2.readContract({ address: opts.novelCore, abi: novelCoreAbi, functionName: "rulesEngine" }),
+    client2.readContract({ address: opts.novelCore, abi: novelCoreAbi, functionName: "roundManager" }),
+    client2.readContract({ address: opts.novelCore, abi: novelCoreAbi, functionName: "userRegistry" })
+  ]);
+  const bountyBoard = await client2.readContract({
+    address: prizePool,
+    abi: prizePoolAbi,
+    functionName: "bountyBoard"
+  });
+  return {
+    novelCore: opts.novelCore,
+    votingEngine,
+    prizePool,
+    rulesEngine,
+    roundManager,
+    userRegistry,
+    bountyBoard
+  };
+}
+var init_resolveContracts = __esm({
+  "../packages/shared/dist/chain/resolveContracts.js"() {
+    "use strict";
+    init_abi();
+  }
+});
+
+// ../packages/shared/dist/chain/contracts.js
+import { encodePacked, keccak256, toHex } from "viem";
+function computeCommitHash(voter, candidateId, salt) {
+  return keccak256(encodePacked(["address", "uint64", "bytes32"], [voter, candidateId, salt]));
+}
+function toBytes32Salt(salt) {
+  const bytes = new TextEncoder().encode(salt);
+  const hex = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return "0x" + hex.padEnd(64, "0");
+}
+async function buildPathToAnchor(client2, novelCore, novelId, from, anchors) {
+  void novelId;
+  const path = [];
+  let cur = from;
+  while (cur !== 0n) {
+    path.push(cur);
+    if (anchors.includes(cur))
+      return path;
+    const ch = await client2.readContract({
+      address: novelCore,
+      abi: novelCoreAbi,
+      functionName: "getChapter",
+      args: [cur]
+    });
+    if (ch.depth <= 1)
+      break;
+    cur = ch.parentId;
+  }
+  return null;
+}
+async function buildWorldLineProof(client2, novelCore, novelId, chapterId) {
+  const ancestors = await client2.readContract({
+    address: novelCore,
+    abi: novelCoreAbi,
+    functionName: "getWorldLineAncestors",
+    args: [novelId]
+  });
+  for (const ancestor of ancestors) {
+    const path = [];
+    let cur = ancestor;
+    while (cur !== 0n) {
+      path.push(cur);
+      if (cur === chapterId)
+        return path;
+      const ch = await client2.readContract({
+        address: novelCore,
+        abi: novelCoreAbi,
+        functionName: "getChapter",
+        args: [cur]
+      });
+      if (ch.depth <= 1)
+        break;
+      cur = ch.parentId;
+    }
+  }
+  return null;
+}
+function buildContentSubmission(content) {
+  const encoded = new TextEncoder().encode(content);
+  const contentBytes = toHex(encoded);
+  const contentHash = keccak256(contentBytes);
+  return {
+    contentHash,
+    declaredLength: BigInt(encoded.length),
+    content: contentBytes
+  };
+}
+async function updateNovelMetadata(client2, params) {
+  return client2.writeContract({
+    address: params.novelCore,
+    abi: novelCoreAbi,
+    functionName: "updateNovelMetadata",
+    args: [params.novelId, params.metadata],
+    chain: client2.chain,
+    account: client2.account
+  });
+}
+async function createNovel(client2, params) {
+  return client2.writeContract({
+    address: params.novelCore,
+    abi: novelCoreAbi,
+    functionName: "createNovel",
+    args: [params.config, params.metadata, params.rootChapter],
+    value: params.value ?? 0n,
+    chain: client2.chain,
+    account: client2.account
+  });
+}
+async function submitChapter(client2, params) {
+  return client2.writeContract({
+    address: params.novelCore,
+    abi: novelCoreAbi,
+    functionName: "submitChapter",
+    args: [params.novelId, params.parentId, params.submission],
+    value: params.value ?? 0n,
+    chain: client2.chain,
+    account: client2.account
+  });
+}
+async function forkNovel(client2, params) {
+  return client2.writeContract({
+    address: params.novelCore,
+    abi: novelCoreAbi,
+    functionName: "forkNovel",
+    args: [params.sourceChapterId, params.config, params.metadata, params.rootChapter],
+    value: params.value ?? 0n,
+    chain: client2.chain,
+    account: client2.account
+  });
+}
+async function claimReward(client2, novelId, novelCore) {
+  return client2.writeContract({
+    address: novelCore,
+    abi: novelCoreAbi,
+    functionName: "claimReward",
+    args: [novelId],
+    chain: client2.chain,
+    account: client2.account
+  });
+}
+async function commitVote(client2, params) {
+  return client2.writeContract({
+    address: params.roundManager,
+    abi: roundManagerAbi,
+    functionName: "commitVote",
+    args: [params.novelId, params.commitHash],
+    value: params.value ?? 0n,
+    chain: client2.chain,
+    account: client2.account
+  });
+}
+async function revealVote(client2, params) {
+  return client2.writeContract({
+    address: params.roundManager,
+    abi: roundManagerAbi,
+    functionName: "revealVote",
+    args: [params.novelId, params.voter, params.candidateId, params.salt],
+    chain: client2.chain,
+    account: client2.account
+  });
+}
+async function startRound(client2, params) {
+  return client2.writeContract({
+    address: params.roundManager,
+    abi: roundManagerAbi,
+    functionName: "startRound",
+    args: [params.novelId, params.leaves],
+    chain: client2.chain,
+    account: client2.account
+  });
+}
+async function closeNomination(client2, novelId, roundManager) {
+  return client2.writeContract({
+    address: roundManager,
+    abi: roundManagerAbi,
+    functionName: "closeNomination",
+    args: [novelId],
+    chain: client2.chain,
+    account: client2.account
+  });
+}
+async function closeCommit(client2, novelId, roundManager) {
+  return client2.writeContract({
+    address: roundManager,
+    abi: roundManagerAbi,
+    functionName: "closeCommit",
+    args: [novelId],
+    chain: client2.chain,
+    account: client2.account
+  });
+}
+async function settleRound(client2, params) {
+  return client2.writeContract({
+    address: params.roundManager,
+    abi: roundManagerAbi,
+    functionName: "settleRound",
+    args: [params.novelId],
+    chain: client2.chain,
+    account: client2.account
+  });
+}
+async function nominateCandidate(client2, params) {
+  return client2.writeContract({
+    address: params.roundManager,
+    abi: roundManagerAbi,
+    functionName: "nominateCandidate",
+    args: [params.novelId, params.chapterId, params.path],
+    value: params.value ?? 0n,
+    chain: client2.chain,
+    account: client2.account
+  });
+}
+async function claimVotingReward(client2, novelId, round, roundManager) {
+  return client2.writeContract({
+    address: roundManager,
+    abi: roundManagerAbi,
+    functionName: "claimVotingReward",
+    args: [novelId, round],
+    chain: client2.chain,
+    account: client2.account
+  });
+}
+async function completeNovel(client2, params) {
+  return client2.writeContract({
+    address: params.roundManager,
+    abi: roundManagerAbi,
+    functionName: "completeNovel",
+    args: [params.novelId],
+    chain: client2.chain,
+    account: client2.account
+  });
+}
+async function tipNovel(client2, params) {
+  return client2.writeContract({
+    address: params.prizePool,
+    abi: prizePoolAbi,
+    functionName: "tipNovel",
+    args: [params.id],
+    value: params.value,
+    chain: client2.chain,
+    account: client2.account
+  });
+}
+async function tipChapter(client2, params) {
+  return client2.writeContract({
+    address: params.prizePool,
+    abi: prizePoolAbi,
+    functionName: "tipChapter",
+    args: [params.id],
+    value: params.value,
+    chain: client2.chain,
+    account: client2.account
+  });
+}
+async function setNickname(client2, nickname, userRegistry) {
+  return client2.writeContract({
+    address: userRegistry,
+    abi: userRegistryAbi,
+    functionName: "setNickname",
+    args: [nickname],
+    chain: client2.chain,
+    account: client2.account
+  });
+}
+async function createBounty(client2, params) {
+  return client2.writeContract({
+    address: params.bountyBoard,
+    abi: bountyBoardAbi,
+    functionName: "createBounty",
+    args: [params.chapterId, params.deadline],
+    value: params.value,
+    chain: client2.chain,
+    account: client2.account
+  });
+}
+async function designateBounty(client2, params) {
+  return client2.writeContract({
+    address: params.bountyBoard,
+    abi: bountyBoardAbi,
+    functionName: "designateBounty",
+    args: [params.bountyId, params.chapterId],
+    chain: client2.chain,
+    account: client2.account
+  });
+}
+async function claimBounty(client2, bountyId, bountyBoard) {
+  return client2.writeContract({
+    address: bountyBoard,
+    abi: bountyBoardAbi,
+    functionName: "claimBounty",
+    args: [bountyId],
+    chain: client2.chain,
+    account: client2.account
+  });
+}
+async function refundBounty(client2, bountyId, bountyBoard) {
+  return client2.writeContract({
+    address: bountyBoard,
+    abi: bountyBoardAbi,
+    functionName: "refundBounty",
+    args: [bountyId],
+    chain: client2.chain,
+    account: client2.account
+  });
+}
+async function setCreatorRules(client2, params) {
+  return client2.writeContract({
+    address: params.rulesEngine,
+    abi: rulesEngineAbi,
+    functionName: "setCreatorRules",
+    args: [params.novelId, params.names, params.contents],
+    chain: client2.chain,
+    account: client2.account
+  });
+}
+async function proposeRule(client2, params) {
+  return client2.writeContract({
+    address: params.rulesEngine,
+    abi: rulesEngineAbi,
+    functionName: "proposeRule",
+    args: [params.novelId, params.proposalType, params.ruleName, params.ruleContent, params.path],
+    value: params.value ?? 0n,
+    chain: client2.chain,
+    account: client2.account
+  });
+}
+async function voteOnRuleProposal(client2, params) {
+  return client2.writeContract({
+    address: params.rulesEngine,
+    abi: rulesEngineAbi,
+    functionName: "voteOnRuleProposal",
+    args: [params.proposalId, params.path],
+    chain: client2.chain,
+    account: client2.account
+  });
+}
+async function getNovel(client2, novelId, novelCore) {
+  return client2.readContract({
+    address: novelCore,
+    abi: novelCoreAbi,
+    functionName: "getNovel",
+    args: [novelId]
+  });
+}
+async function getChapter(client2, chapterId, novelCore) {
+  return client2.readContract({
+    address: novelCore,
+    abi: novelCoreAbi,
+    functionName: "getChapter",
+    args: [chapterId]
+  });
+}
+async function getWorldLineAncestors(client2, novelId, novelCore) {
+  return client2.readContract({
+    address: novelCore,
+    abi: novelCoreAbi,
+    functionName: "getWorldLineAncestors",
+    args: [novelId]
+  });
+}
+async function getRoundData(client2, novelId, round, roundManager) {
+  return client2.readContract({
+    address: roundManager,
+    abi: roundManagerAbi,
+    functionName: "getRoundData",
+    args: [novelId, round]
+  });
+}
+async function getNovelMetadata(client2, novelId, novelCore) {
+  return client2.readContract({
+    address: novelCore,
+    abi: novelCoreAbi,
+    functionName: "getNovelMetadata",
+    args: [novelId]
+  });
+}
+async function getPoolBalance(client2, novelId, prizePool) {
+  return client2.readContract({
+    address: prizePool,
+    abi: prizePoolAbi,
+    functionName: "getPoolBalance",
+    args: [novelId]
+  });
+}
+async function getRuleNames(client2, novelId, rulesEngine) {
+  return client2.readContract({
+    address: rulesEngine,
+    abi: rulesEngineAbi,
+    functionName: "getRuleNames",
+    args: [novelId]
+  });
+}
+async function getRule(client2, novelId, name, rulesEngine) {
+  return client2.readContract({
+    address: rulesEngine,
+    abi: rulesEngineAbi,
+    functionName: "getRule",
+    args: [novelId, name]
+  });
+}
+async function getRuleProposal(client2, proposalId, rulesEngine) {
+  return client2.readContract({
+    address: rulesEngine,
+    abi: rulesEngineAbi,
+    functionName: "getRuleProposal",
+    args: [proposalId]
+  });
+}
+async function getNickname(client2, user, userRegistry) {
+  return client2.readContract({
+    address: userRegistry,
+    abi: userRegistryAbi,
+    functionName: "nicknames",
+    args: [user]
+  });
+}
+var init_contracts = __esm({
+  "../packages/shared/dist/chain/contracts.js"() {
+    "use strict";
+    init_abi();
+  }
+});
+
+// ../packages/shared/dist/chain/index.js
+var init_chain = __esm({
+  "../packages/shared/dist/chain/index.js"() {
+    "use strict";
+    init_abi();
+    init_contracts();
+    init_resolveContracts();
+  }
+});
+
+// src/shared/index.ts
+var shared_exports = {};
+__export(shared_exports, {
+  bountyBoardAbi: () => bountyBoardAbi,
+  buildContentSubmission: () => buildContentSubmission,
+  buildPathToAnchor: () => buildPathToAnchor,
+  buildWorldLineProof: () => buildWorldLineProof,
+  claimBounty: () => claimBounty,
+  claimReward: () => claimReward,
+  claimVotingReward: () => claimVotingReward,
+  closeCommit: () => closeCommit,
+  closeNomination: () => closeNomination,
+  commitVote: () => commitVote,
+  completeNovel: () => completeNovel,
+  computeCommitHash: () => computeCommitHash,
+  createBounty: () => createBounty,
+  createNovel: () => createNovel,
+  designateBounty: () => designateBounty,
+  forkNovel: () => forkNovel,
+  getChapter: () => getChapter,
+  getNickname: () => getNickname,
+  getNovel: () => getNovel,
+  getNovelMetadata: () => getNovelMetadata,
+  getPoolBalance: () => getPoolBalance,
+  getRoundData: () => getRoundData,
+  getRule: () => getRule,
+  getRuleNames: () => getRuleNames,
+  getRuleProposal: () => getRuleProposal,
+  getWorldLineAncestors: () => getWorldLineAncestors,
+  nominateCandidate: () => nominateCandidate,
+  novelCoreAbi: () => novelCoreAbi,
+  prizePoolAbi: () => prizePoolAbi,
+  proposeRule: () => proposeRule,
+  refundBounty: () => refundBounty,
+  resolveContracts: () => resolveContracts,
+  revealVote: () => revealVote,
+  roundManagerAbi: () => roundManagerAbi,
+  rulesEngineAbi: () => rulesEngineAbi,
+  setCreatorRules: () => setCreatorRules,
+  setNickname: () => setNickname,
+  settleRound: () => settleRound,
+  startRound: () => startRound,
+  submitChapter: () => submitChapter,
+  tipChapter: () => tipChapter,
+  tipNovel: () => tipNovel,
+  toBytes32Salt: () => toBytes32Salt,
+  updateNovelMetadata: () => updateNovelMetadata,
+  userRegistryAbi: () => userRegistryAbi,
+  voteOnRuleProposal: () => voteOnRuleProposal,
+  votingEngineAbi: () => votingEngineAbi
+});
+var init_shared = __esm({
+  "src/shared/index.ts"() {
+    "use strict";
+    init_chain();
+  }
+});
+
+// src/bin/onchain-novel-cli.ts
+import { program } from "commander";
+
+// ../packages/shared/dist/config.js
+init_resolveContracts();
+import { existsSync, readFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+import YAML from "yaml";
+import { z } from "zod";
+import { createPublicClient as createPublicClient2, http as http2 } from "viem";
+var addressLike = z.union([z.string(), z.number()]).transform((v) => String(v));
+var hexAddress = addressLike.pipe(z.string().regex(/^0x[0-9a-fA-F]{40}$/, "expected 0x-prefixed 20-byte hex address").transform((s) => s));
+var optionalHexAddress = z.union([z.string(), z.number()]).optional().transform((v) => {
+  if (v === void 0)
+    return void 0;
+  const s = String(v);
+  return s.length > 0 ? s : void 0;
+});
+var NativeCurrencySchema = z.object({
+  name: z.string().default("Ether"),
+  symbol: z.string().default("ETH"),
+  decimals: z.number().int().positive().default(18)
+}).default({});
+var ChainSchema = z.object({
+  rpcUrl: z.string().url(),
+  // Optional: when omitted, callers resolve via `eth_chainId` against rpcUrl
+  // (see bootstrapConfig). Keep it as an explicit override for offline tooling
+  // or for sanity-checking against an expected network.
+  chainId: z.number().int().positive().optional(),
+  nativeCurrency: NativeCurrencySchema
+});
+var ContractsSchema = z.object({
+  novelCore: optionalHexAddress
+});
+var IndexerSchema = z.object({
+  startBlock: z.number().int().nonnegative().default(0),
+  pollIntervalMs: z.number().int().positive().default(5e3),
+  confirmationBlocks: z.number().int().nonnegative().default(12),
+  batchSize: z.number().int().positive().default(100)
+});
+var KeeperSchema = z.object({
+  pollIntervalMs: z.number().int().positive().default(1e4)
+});
+var BackendSchema = z.object({
+  host: z.string().default("127.0.0.1"),
+  port: z.number().int().positive().default(3001),
+  // CLI-only configs (e.g. onchain-novel-cli setup) omit this section; backend
+  // runtime still needs a real URL, but the placeholder here keeps schema
+  // validation happy and the backend itself errors later with a clearer message
+  // if it tries to connect to a non-existent database.
+  databaseUrl: z.string().min(1).default("postgresql://127.0.0.1:5432/onchain_novel"),
+  indexer: IndexerSchema.default({}),
+  keeper: KeeperSchema.default({})
+});
+var FrontendSchema = z.object({
+  port: z.number().int().positive().default(3e3),
+  backendUrl: z.string().url().default("http://127.0.0.1:3001"),
+  // Extra Next.js dev-server origins allowed for HMR etc. Empty = same-origin only.
+  allowedDevOrigins: z.array(z.string()).default([])
+});
+var CliSchema = z.object({
+  apiUrl: z.string().url().default("http://127.0.0.1:3001"),
+  // Base URL of the frontend. Full chapter path is constructed as
+  // `{frontUrl}/novels/{novelId}/chapter/{chapterId}` at runtime.
+  frontUrl: z.string().url().default("http://34.135.19.173:8546"),
+  // Base URL of the chain explorer. Full tx path is constructed as
+  // `{chainExplorer}/tx/{txHash}` at runtime.
+  chainExplorer: z.string().url().default("https://mainnet-explorer.gravity.xyz")
+});
+var AppConfigSchema = z.object({
+  chain: ChainSchema,
+  contracts: ContractsSchema.default({}),
+  backend: BackendSchema.default({}),
+  frontend: FrontendSchema.default({}),
+  cli: CliSchema.default({})
+});
+function findRepoRoot(startDir) {
+  let dir = resolve(startDir);
+  while (true) {
+    if (existsSync(join(dir, "config.yaml")) || existsSync(join(dir, "foundry.toml"))) {
+      return dir;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) {
+      throw new Error(`Could not find repo root from ${startDir} \u2014 no config.yaml or foundry.toml anchor found.`);
+    }
+    dir = parent;
+  }
+}
+function readYaml(path) {
+  const raw = readFileSync(path, "utf-8");
+  const parsed = YAML.parse(raw);
+  if (parsed === null || parsed === void 0)
+    return {};
+  if (typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Expected YAML object at top level of ${path}`);
+  }
+  return parsed;
+}
+function loadConfig(opts = {}) {
+  const searchFrom = opts.searchFrom ?? process.cwd();
+  const explicitPath = opts.configPath ?? process.env.ONCHAIN_NOVEL_CONFIG;
+  let mainPath;
+  let root;
+  if (explicitPath) {
+    mainPath = resolve(explicitPath);
+    root = dirname(mainPath);
+  } else {
+    root = findRepoRoot(searchFrom);
+    mainPath = join(root, "config.yaml");
+  }
+  if (!existsSync(mainPath)) {
+    throw new Error(`config.yaml not found at ${mainPath}`);
+  }
+  let merged = readYaml(mainPath);
+  const result = AppConfigSchema.safeParse(merged);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new Error(`Invalid config (${mainPath}):
+${issues}`);
+  }
+  return result.data;
+}
+function getPrivateKey() {
+  const pk = process.env.PRIVATE_KEY?.trim();
+  if (!pk)
+    return null;
+  return pk.startsWith("0x") ? pk : `0x${pk}`;
+}
+async function bootstrapConfig(opts = {}) {
+  const config = loadConfig(opts);
+  if (!config.contracts.novelCore) {
+    throw new Error("Missing contracts.novelCore in config.yaml. Run scripts/deploy.sh, then patch-config.ts will fill it in.");
+  }
+  const client2 = createPublicClient2({ transport: http2(config.chain.rpcUrl) });
+  const [chainId, contracts] = await Promise.all([
+    config.chain.chainId !== void 0 ? Promise.resolve(config.chain.chainId) : client2.getChainId(),
+    resolveContracts({ novelCore: config.contracts.novelCore, client: client2 })
+  ]);
+  return { config, chainId, contracts };
+}
+
+// src/utils/config.ts
+var _cache = null;
+async function ensureBootstrapped() {
+  if (_cache) return;
+  try {
+    _cache = await bootstrapConfig();
+  } catch (err) {
+    console.error(String(err));
+    process.exit(1);
+  }
+}
+function requireConfig() {
+  if (!_cache) {
+    console.error(
+      "CLI bootstrap was not called for this command. This is a bug \u2014 please file an issue."
+    );
+    process.exit(1);
+  }
+  const { config, chainId, contracts } = _cache;
+  return {
+    rpcUrl: config.chain.rpcUrl,
+    chainId,
+    nativeCurrency: config.chain.nativeCurrency,
+    apiUrl: config.cli.apiUrl,
+    frontUrl: config.cli.frontUrl,
+    chainExplorer: config.cli.chainExplorer,
+    contracts
+  };
+}
+function getPrivateKey2() {
+  return getPrivateKey();
+}
+
+// src/utils/format.ts
+import chalk from "chalk";
+import { formatUnits } from "viem";
+function kv(label, value) {
+  console.log(`  ${chalk.gray(label + ":")} ${value}`);
+}
+function header(text) {
+  console.log(chalk.bold.cyan(`
+${text}`));
+  console.log(chalk.gray("\u2500".repeat(60)));
+}
+function success(msg) {
+  console.log(chalk.green(`\u2713 ${msg}`));
+}
+function error(msg) {
+  console.error(chalk.red(`\u2717 ${msg}`));
+}
+function txHash(hash) {
+  console.log(chalk.green(`\u2713 Transaction sent: ${hash}`));
+}
+function token(wei, decimals, symbol) {
+  const val = typeof wei === "string" ? BigInt(wei) : wei;
+  return `${formatUnits(val, decimals)} ${symbol}`;
+}
+function table(rows, columns) {
+  if (rows.length === 0) {
+    console.log(chalk.gray("  (no results)"));
+    return;
+  }
+  const cols = columns ?? Object.keys(rows[0]);
+  const widths = cols.map(
+    (col) => Math.max(col.length, ...rows.map((r) => String(r[col] ?? "").length))
+  );
+  const headerLine = cols.map((col, i) => col.padEnd(widths[i])).join("  ");
+  console.log(chalk.bold("  " + headerLine));
+  console.log(chalk.gray("  " + widths.map((w) => "\u2500".repeat(w)).join("  ")));
+  for (const row of rows) {
+    const line = cols.map((col, i) => String(row[col] ?? "").padEnd(widths[i])).join("  ");
+    console.log("  " + line);
+  }
+}
+function parseDuration(duration) {
+  const match = duration.match(/^(\d+)(s|m|h|d)$/);
+  if (!match) {
+    throw new Error(`Invalid duration format: ${duration}. Use <number>(s|m|h|d), e.g., 7d, 24h`);
+  }
+  const value = parseInt(match[1]);
+  const unit = match[2];
+  switch (unit) {
+    case "s":
+      return value;
+    case "m":
+      return value * 60;
+    case "h":
+      return value * 3600;
+    case "d":
+      return value * 86400;
+    default:
+      throw new Error(`Unknown unit: ${unit}`);
+  }
+}
+function roundPhaseName(phase) {
+  switch (phase) {
+    case 0:
+      return "Idle";
+    case 1:
+      return "Nominating";
+    case 2:
+      return "Committing";
+    case 3:
+      return "Revealing";
+    default:
+      return `Unknown(${phase})`;
+  }
+}
+
+// src/commands/admin.ts
+async function adminFetch(method, path, label) {
+  const cfg = requireConfig();
+  const url = `${cfg.apiUrl}${path}`;
+  header(label);
+  try {
+    const res = await fetch(url, { method });
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      error(`Backend returned ${res.status}: ${body.error ?? "unknown error"}`);
+      process.exit(1);
+    }
+    const id = body.deleted ?? body.restored;
+    success(`${label} \u2014 Novel #${id}. On-chain data is unchanged.`);
+  } catch (err) {
+    error(`Could not reach backend at ${cfg.apiUrl}: ${String(err)}`);
+    process.exit(1);
+  }
+}
+function registerAdminCommands(program2) {
+  const admin = program2.command("admin").description("Admin commands (localhost-only backend calls)");
+  admin.command("delete-novel <novel-id>").description("Hide a novel and all its chapters from the frontend.").action(async (novelId) => {
+    await adminFetch("DELETE", `/api/admin/novels/${novelId}`, `Delete Novel #${novelId}`);
+  });
+  admin.command("restore-novel <novel-id>").description("Restore a previously hidden novel and its chapters.").action(async (novelId) => {
+    await adminFetch("POST", `/api/admin/novels/${novelId}/restore`, `Restore Novel #${novelId}`);
+  });
+}
+
+// src/commands/bounty.ts
+init_shared();
+import { parseEther } from "viem";
+
+// ../packages/shared/dist/api/client.js
+function createApiClient(options) {
+  const base = options.baseUrl.replace(/\/+$/, "");
+  const root = base.endsWith("/api") ? base : `${base}/api`;
+  async function get(path) {
+    const res = await fetch(`${root}${path}`, {
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`API ${res.status}: ${body}`);
+    }
+    return res.json();
+  }
+  async function post(path, body) {
+    const res = await fetch(`${root}${path}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    let parsed = null;
+    try {
+      parsed = await res.json();
+    } catch {
+      parsed = null;
+    }
+    return { status: res.status, body: parsed };
+  }
+  return {
+    get,
+    post,
+    fetchNovels(params) {
+      const sp = new URLSearchParams();
+      if (params.page)
+        sp.set("page", String(params.page));
+      if (params.limit)
+        sp.set("limit", String(params.limit));
+      if (params.sort)
+        sp.set("sort", params.sort);
+      if (params.filter)
+        sp.set("filter", params.filter);
+      if (params.search)
+        sp.set("search", params.search);
+      return get(`/novels?${sp.toString()}`);
+    },
+    fetchNovel(id) {
+      return get(`/novels/${id}`);
+    },
+    fetchNovelTree(id, maxDepth) {
+      const q = maxDepth ? `?maxDepth=${maxDepth}` : "";
+      return get(`/novels/${id}/tree${q}`);
+    },
+    fetchWorldlines(id) {
+      return get(`/novels/${id}/worldlines`);
+    },
+    fetchNovelLines(id, mode = "longest", limit) {
+      const sp = new URLSearchParams({ mode });
+      if (limit)
+        sp.set("limit", String(limit));
+      return get(`/novels/${id}/lines?${sp.toString()}`);
+    },
+    fetchRound(novelId, round) {
+      return get(`/novels/${novelId}/rounds/${round}`);
+    },
+    fetchChapter(id) {
+      return get(`/chapters/${id}`);
+    },
+    fetchChapterContext(id) {
+      return get(`/chapters/${id}/context`);
+    },
+    fetchChapterChildren(id) {
+      return get(`/chapters/${id}/children`);
+    },
+    fetchChapterBounties(id) {
+      return get(`/chapters/${id}/bounties`);
+    },
+    fetchChapterTips(id) {
+      return get(`/chapters/${id}/tips`);
+    },
+    fetchComments(chapterId, page = 1, limit = 20) {
+      return get(`/chapters/${chapterId}/comments?page=${page}&limit=${limit}`);
+    },
+    fetchNickname(address) {
+      return get(`/users/${address}/nickname`);
+    },
+    fetchNicknamesBatch(addresses) {
+      if (addresses.length === 0) {
+        return Promise.resolve({ nicknames: {} });
+      }
+      return get(`/users/nicknames/batch?addresses=${addresses.join(",")}`);
+    },
+    fetchUserChapters(address) {
+      return get(`/users/${address}/chapters`);
+    },
+    fetchUserVotes(address, page = 1) {
+      return get(`/users/${address}/votes?page=${page}`);
+    },
+    fetchUserRewards(address) {
+      return get(`/users/${address}/rewards`);
+    },
+    async postComment(chapterId, body) {
+      const r = await post(`/chapters/${chapterId}/comments`, body);
+      if (r.status === 201 && r.body)
+        return { ok: true, comment: r.body };
+      return {
+        ok: false,
+        status: r.status,
+        error: r.body ? JSON.stringify(r.body) : ""
+      };
+    },
+    async submitVotePlaintext(body) {
+      const r = await post(`/votes/submit`, body);
+      return { status: r.status, ok: r.status === 201 };
+    }
+  };
+}
+
+// src/utils/api.ts
+var _client = null;
+function client() {
+  if (!_client) {
+    _client = createApiClient({ baseUrl: requireConfig().apiUrl });
+  }
+  return _client;
+}
+function apiGet(path) {
+  const stripped = path.replace(/^\/api/, "");
+  return client().get(stripped);
+}
+function apiPost(path, body) {
+  const stripped = path.replace(/^\/api/, "");
+  return client().post(stripped, body);
+}
+async function fetchNovelConfig(novelId) {
+  const novel = await client().fetchNovel(novelId);
+  const config = novel.config;
+  if (!config) {
+    throw new Error(
+      `Novel #${novelId} has no config in backend response. Pass the fee explicitly via --value.`
+    );
+  }
+  return { novel, config };
+}
+
+// src/utils/client.ts
+import {
+  createPublicClient as createPublicClient3,
+  createWalletClient,
+  defineChain,
+  http as http3
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+function getChain() {
+  const config = requireConfig();
+  return defineChain({
+    id: config.chainId,
+    name: `Chain ${config.chainId}`,
+    nativeCurrency: config.nativeCurrency,
+    rpcUrls: { default: { http: [config.rpcUrl] } }
+  });
+}
+function getPublicClient() {
+  const config = requireConfig();
+  return createPublicClient3({
+    chain: getChain(),
+    transport: http3(config.rpcUrl)
+  });
+}
+function getWalletClient() {
+  const config = requireConfig();
+  const pk = getPrivateKey2();
+  if (!pk) {
+    console.error(
+      "PRIVATE_KEY env var not set. The CLI never persists secrets; export it in your shell:\n  export PRIVATE_KEY=0x...\nOr inject it with a secret manager (direnv, 1Password CLI, etc)."
+    );
+    process.exit(1);
+  }
+  const account = privateKeyToAccount(pk);
+  return createWalletClient({
+    account,
+    chain: getChain(),
+    transport: http3(config.rpcUrl)
+  });
+}
+function getContracts() {
+  const config = requireConfig();
+  return config.contracts;
+}
+async function waitForTx(hash) {
+  const client2 = getPublicClient();
+  const receipt = await client2.waitForTransactionReceipt({ hash });
+  if (receipt.status !== "success") {
+    throw new Error(`Transaction ${hash} reverted`);
+  }
+  return receipt;
+}
+
+// src/commands/bounty.ts
+function registerBountyCommands(program2) {
+  const bounty = program2.command("bounty").description("Bounty commands");
+  bounty.command("create <chapter-id>").description("Create a bounty to incentivize writing continuations").requiredOption("--value <eth>", "bounty amount in ETH").requiredOption("--deadline <duration>", "deadline from now (e.g., 7d, 24h, 30m)").action(async (chapterId, opts) => {
+    try {
+      const client2 = getWalletClient();
+      const contracts = getContracts();
+      const durationSeconds = parseDuration(opts.deadline);
+      const deadlineTimestamp = BigInt(Math.floor(Date.now() / 1e3) + durationSeconds);
+      const hash = await createBounty(client2, {
+        chapterId: BigInt(chapterId),
+        deadline: deadlineTimestamp,
+        value: parseEther(opts.value),
+        bountyBoard: contracts.bountyBoard
+      });
+      txHash(hash);
+      await waitForTx(hash);
+      success(
+        `Bounty created for chapter ID.${chapterId} (${opts.value} ETH, deadline: ${opts.deadline})`
+      );
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  bounty.command("designate <bounty-id> <chapter-id>").description("Designate a preferred continuation for your bounty (before deadline)").action(async (bountyId, chapterId) => {
+    try {
+      const client2 = getWalletClient();
+      const contracts = getContracts();
+      const hash = await designateBounty(client2, {
+        bountyId: BigInt(bountyId),
+        chapterId: BigInt(chapterId),
+        bountyBoard: contracts.bountyBoard
+      });
+      txHash(hash);
+      await waitForTx(hash);
+      success(`Bounty #${bountyId} designated chapter ID.${chapterId}`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  bounty.command("list").description("List active bounties (earning opportunities)").option("--novel-id <id>", "Filter by novel ID").action(async (opts) => {
+    try {
+      const { nativeCurrency } = requireConfig();
+      const url = opts.novelId ? `/api/bounties/active?novelId=${opts.novelId}` : "/api/bounties/active";
+      const data = await apiGet(url);
+      if (data.bounties.length === 0) {
+        console.log("No active bounties found.");
+        return;
+      }
+      header("Active Bounties");
+      for (const b of data.bounties) {
+        kv(`Bounty #${b.id}`, `Chapter ID.${b.chapter_id} (${b.novel_title})`);
+        kv("  Locked", token(BigInt(String(b.locked_amount ?? "0")), nativeCurrency.decimals, nativeCurrency.symbol));
+        if (b.create_time) kv("  Created", new Date(Number(b.create_time) * 1e3).toISOString());
+        kv("  Deadline", new Date(Number(b.deadline) * 1e3).toISOString());
+        if (Number(b.designated_chapter_id) > 0) {
+          kv("  Designated", `Chapter ID.${b.designated_chapter_id}`);
+        }
+        console.log();
+      }
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  bounty.command("claim <bounty-id>").description("Claim bounty reward (for qualifying authors after deadline)").action(async (bountyId) => {
+    try {
+      const client2 = getWalletClient();
+      const contracts = getContracts();
+      const hash = await claimBounty(client2, BigInt(bountyId), contracts.bountyBoard);
+      txHash(hash);
+      await waitForTx(hash);
+      success("Bounty claimed");
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  bounty.command("refund <bounty-id>").description("Refund bounty (if no continuations were submitted before deadline)").action(async (bountyId) => {
+    try {
+      const client2 = getWalletClient();
+      const contracts = getContracts();
+      const hash = await refundBounty(client2, BigInt(bountyId), contracts.bountyBoard);
+      txHash(hash);
+      await waitForTx(hash);
+      success("Bounty refunded");
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  bounty.command("info <bounty-id>").description("Show bounty details").action(async (bountyId) => {
+    try {
+      const { nativeCurrency } = requireConfig();
+      const data = await apiGet(`/api/bounties/${bountyId}`);
+      header(`Bounty #${bountyId}`);
+      kv("Chapter", `ID.${data.chapter_id} (${data.novel_title})`);
+      kv("Tipper", data.tipper);
+      kv("Locked Amount", token(BigInt(String(data.locked_amount ?? "0")), nativeCurrency.decimals, nativeCurrency.symbol));
+      kv("Deadline", data.deadline);
+      kv("Claimed", data.claimed ? "Yes" : "No");
+      console.log();
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/chapter.ts
+init_shared();
+import { existsSync as existsSync2, mkdirSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+import chalk3 from "chalk";
+import { decodeEventLog, parseAbiItem, parseEther as parseEther2 } from "viem";
+
+// src/utils/content.ts
+import { readFileSync as readFileSync2, statSync } from "fs";
+import chalk2 from "chalk";
+function resolveContent(opts) {
+  if (opts.content && opts.file) {
+    throw new Error("Pass only one of --content or --file, not both.");
+  }
+  if (!opts.content && !opts.file) {
+    throw new Error("Missing chapter content. Pass --content <text> or --file <path>.");
+  }
+  if (opts.file) {
+    const st = statSync(opts.file);
+    if (!st.isFile()) throw new Error(`--file ${opts.file} is not a regular file.`);
+    return readFileSync2(opts.file, "utf-8");
+  }
+  return opts.content;
+}
+function warnIfOutOfRange(content, cfg) {
+  if (!cfg) return;
+  const bytes = Buffer.byteLength(content, "utf-8");
+  const min = cfg.minChapterLength ? Number(cfg.minChapterLength) : 0;
+  const max = cfg.maxChapterLength ? Number(cfg.maxChapterLength) : 0;
+  if (min > 0 && bytes < min) {
+    console.log(
+      chalk2.yellow(
+        `  \u26A0 content is ${bytes} bytes; novel requires \u2265 ${min}. Submission will revert.`
+      )
+    );
+  }
+  if (max > 0 && bytes > max) {
+    console.log(
+      chalk2.yellow(
+        `  \u26A0 content is ${bytes} bytes; novel allows \u2264 ${max}. Submission will revert.`
+      )
+    );
+  }
+}
+
+// src/commands/chapter.ts
+function renderNotesSkeleton(id, depth, parentId) {
+  const isRoot = String(parentId) === "0";
+  const header2 = `# ID.${id} \u2014 ch${depth}, ${isRoot ? "root (no parent)" : `continues from ID.${parentId}`}`;
+  const preamble = `<!-- This file is your STRUCTURED analysis of chapter ${id}. Filling it IS the act
+of understanding \u2014 skimming the raw content without writing notes means you have
+not analyzed this chapter.
+
+Remove each <!-- TODO --> marker once you finish that section. A gate before
+drafting (Step 5) checks that every ancestor's notes have zero TODO markers. -->`;
+  const happened = `## \u672C\u7AE0\u4E3B\u8981\u53D1\u751F\u4E86\u4EC0\u4E48
+<!-- TODO: 3-6 \u53E5\u5177\u4F53\u60C5\u8282\u3002
+     \u2713 \u597D\uFF1A"A \u4E3A\u6551 B \u62D4\u67AA\u5C04\u4E2D\u4E86 C \u7684\u80A9\u8180\uFF0CC \u9000\u5374\u4F46\u8BA4\u51FA\u4E86 A \u6234\u7684\u5341\u5B57\u540A\u5760\u3002"
+     \u2717 \u5DEE\uFF1A"\u5C55\u5F00\u4E86\u4E00\u573A\u7D27\u5F20\u7684\u5BF9\u51B3\u3002" -->`;
+  const delta = isRoot ? `## \u521D\u59CB\u4E16\u754C\u8BBE\u5B9A
+<!-- TODO: \u65F6\u95F4 / \u5730\u70B9 / \u4E3B\u8981\u4EBA\u7269 / \u6743\u529B\u683C\u5C40 / \u6280\u672F\u6C34\u5E73 / \u6587\u5316\u7279\u5F81\u3002
+     \u8FD9\u662F\u540E\u7EED\u6240\u6709\u7EED\u5199\u7684\u8D77\u70B9\uFF0C\u8981\u5177\u4F53\u3002 -->` : `## \u76F8\u5BF9 parent \u63A8\u8FDB\u4E86\u4EC0\u4E48
+<!-- TODO: \u72B6\u6001\u589E\u91CF\u3002\u4EFB\u9009\u9002\u7528\uFF1A
+     - \u8C01\u7684\u4F4D\u7F6E / \u5904\u5883\u53D8\u4E86
+     - \u8C01\u548C\u8C01\u7684\u5173\u7CFB\u53D8\u4E86
+     - \u8C01\u77E5\u9053\u4E86\u4EC0\u4E48\u4E4B\u524D\u4E0D\u77E5\u9053\u7684\u4E8B
+     - \u54EA\u4E2A\u60AC\u5FF5\u88AB\u89E3\u5F00 / \u52A0\u6DF1
+     - \u4E16\u754C\u683C\u5C40\u6709\u4EC0\u4E48\u53D8\u5316 -->`;
+  const newElements = `## \u65B0\u5F15\u5165\u7684\u5143\u7D20
+<!-- TODO: \u672C\u7AE0\u624D\u51FA\u73B0\u7684\uFF1A
+     - \u65B0\u4EBA\u7269\uFF08\u540D\u5B57\u3001\u8EAB\u4EFD\u3001\u5173\u7CFB\uFF09
+     - \u65B0\u5730\u70B9 / \u65B0\u7EC4\u7EC7 / \u65B0\u8BBE\u5B9A
+     - \u65B0\u4F0F\u7B14
+     \u82E5\u5B8C\u5168\u65E0\u65B0\u5143\u7D20\uFF0C\u76F4\u63A5\u5199"\u65E0"\u3002 -->`;
+  const hooks = `## \u57CB\u4E0B / \u6536\u5272\u7684\u94A9\u5B50
+<!-- TODO:
+     - \u57CB\u4E0B\uFF1A\u672C\u7AE0\u7559\u4E0B\u7684\u65B0\u60AC\u5FF5\u3002\u5177\u4F53\u4E9B\uFF0C\u4E0D\u8981"\u4E00\u4E2A\u795E\u79D8\u7684\u9884\u611F"\u3002
+     - \u6536\u5272${isRoot ? "\uFF08root \u7AE0\u8282\u901A\u5E38\u65E0\u53EF\u6536\u5272\uFF0C\u7559\u7A7A\u6216\u5199'\u65E0'\uFF09" : ""}\uFF1A\u672C\u7AE0\u89E3\u7B54\u4E86 / \u63A8\u8FDB\u4E86\u54EA\u4E2A ancestor \u7684\u60AC\u5FF5\uFF1F\u6CE8\u660E ancestor chapterId\u3002 -->`;
+  const voice = `## \u8BED\u6C14\u548C\u98CE\u683C\u7279\u5F81
+<!-- TODO: 1-2 \u53E5\uFF0C\u591F\u4E0B\u4E00\u4F4D\u4F5C\u8005\u5339\u914D voice \u5C31\u884C\u3002
+     \u4F8B\uFF1A"\u7B2C\u4E09\u4EBA\u79F0\u9650\u77E5\u89C6\u89D2\uFF0C\u51B7\u5CFB\u514B\u5236\u7684\u77ED\u53E5\uFF0C\u5927\u91CF\u611F\u5B98\u7EC6\u8282\uFF0C\u5BF9\u8BDD\u4E0D\u7528\u5F15\u53F7\u3002" -->`;
+  return [header2, preamble, happened, delta, newElements, hooks, voice].join("\n\n") + "\n";
+}
+function registerChapterCommands(program2) {
+  const chapter = program2.command("chapter").description("Chapter commands");
+  chapter.command("submit <novel-id> <parent-id>").description("Submit a new chapter").option("--content <text>", "chapter content (mutually exclusive with --file)").option("--file <path>", "read chapter content from a UTF-8 text file").option("--value <eth>", "submission fee in ETH (auto-detected from novel config if not set)").action(async (novelId, parentId, opts) => {
+    try {
+      const client2 = getWalletClient();
+      const contracts = getContracts();
+      const content = resolveContent(opts);
+      let value;
+      let novelConfig;
+      if (opts.value) {
+        value = parseEther2(opts.value);
+      } else {
+        const { config } = await fetchNovelConfig(novelId);
+        novelConfig = config;
+        value = BigInt(config.submissionFee ?? "0");
+      }
+      warnIfOutOfRange(content, novelConfig);
+      const submission = buildContentSubmission(content);
+      const hash = await submitChapter(client2, {
+        novelId: BigInt(novelId),
+        parentId: BigInt(parentId),
+        submission,
+        value,
+        novelCore: contracts.novelCore
+      });
+      txHash(hash);
+      const receipt = await waitForTx(hash);
+      const chapterSubmittedTopic = parseAbiItem(
+        "event ChapterSubmitted(uint64 indexed novelId, uint64 indexed chapterId, address indexed author, uint64 parentId, uint32 depth)"
+      );
+      let newChapterId;
+      for (const log of receipt.logs) {
+        try {
+          const decoded = decodeEventLog({ abi: [chapterSubmittedTopic], data: log.data, topics: log.topics });
+          if (decoded.eventName === "ChapterSubmitted") {
+            newChapterId = decoded.args.chapterId;
+            break;
+          }
+        } catch {
+        }
+      }
+      if (newChapterId !== void 0) {
+        kv("Chapter ID", newChapterId.toString());
+      }
+      success("Chapter submitted");
+      const cfg = requireConfig();
+      const frontendUrl = newChapterId !== void 0 ? `${cfg.frontUrl}/novels/${novelId}/chapter/${newChapterId}` : `${cfg.frontUrl}/novels/${novelId}`;
+      const explorerUrl = `${cfg.chainExplorer}/tx/${hash}`;
+      console.log(chalk3.blue(`  Frontend: ${frontendUrl}`));
+      console.log(chalk3.blue(`  Explorer: ${explorerUrl}`));
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  chapter.command("read <chapter-id>").description("Read a chapter's details and content").action(async (chapterId) => {
+    try {
+      const data = await apiGet(`/api/chapters/${chapterId}`);
+      header(`Chapter ID.${chapterId}`);
+      kv("Novel", `${data.novel_title} (#${data.novel_id})`);
+      kv("Author", data.author);
+      kv("Parent", `ID.${data.parent_id}`);
+      kv("Depth", data.depth);
+      kv("World Line", data.is_world_line ? "Yes" : "No");
+      kv("Length", data.declared_length);
+      kv("Timestamp", data.timestamp);
+      kv("Content Hash", data.content_hash);
+      if (data.content_text) {
+        console.log(chalk3.gray("\n\u2500\u2500\u2500 Content \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+        console.log(String(data.content_text));
+        console.log(chalk3.gray("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n"));
+      } else if (data.content_fetched === false) {
+        console.log(chalk3.yellow("\n  Content not yet indexed.\n"));
+      }
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  chapter.command("tree <novel-id>").description("Show the chapter tree of a novel").action(async (novelId) => {
+    try {
+      let printTree2 = function(id, prefix, isLast) {
+        const ch = byId.get(id);
+        const connector = isLast ? "\\-- " : "|-- ";
+        const wl = ch.is_world_line ? chalk3.green(" *") : "";
+        const authorShort = String(ch.author ?? "").slice(0, 8);
+        console.log(`${prefix}${connector}ID.${ch.id} (d=${ch.depth}) by ${authorShort}..${wl}`);
+        const kids = children.get(id) ?? [];
+        for (let i = 0; i < kids.length; i++) {
+          const childPrefix = prefix + (isLast ? "    " : "|   ");
+          printTree2(kids[i], childPrefix, i === kids.length - 1);
+        }
+      };
+      var printTree = printTree2;
+      const data = await apiGet(
+        `/api/novels/${novelId}/tree`
+      );
+      header(`Chapter Tree \u2014 Novel #${novelId}`);
+      if (data.chapters.length === 0) {
+        console.log(chalk3.gray("  (no chapters)"));
+        return;
+      }
+      const byId = /* @__PURE__ */ new Map();
+      const children = /* @__PURE__ */ new Map();
+      for (const ch of data.chapters) {
+        const id = String(ch.id);
+        byId.set(id, ch);
+        const parentId = String(ch.parent_id);
+        if (!children.has(parentId)) children.set(parentId, []);
+        children.get(parentId).push(id);
+      }
+      const roots = data.chapters.filter(
+        (ch) => String(ch.parent_id) === "0" || !byId.has(String(ch.parent_id))
+      );
+      for (let i = 0; i < roots.length; i++) {
+        printTree2(String(roots[i].id), "  ", i === roots.length - 1);
+      }
+      console.log(chalk3.gray("\n  * = world line\n"));
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  chapter.command("children <chapter-id>").description("Show direct children of a chapter").action(async (chapterId) => {
+    try {
+      const data = await apiGet(
+        `/api/chapters/${chapterId}/children`
+      );
+      header(`Children of Chapter ID.${chapterId}`);
+      table(
+        data.children.map((ch) => ({
+          ID: ch.id,
+          Author: String(ch.author ?? "").slice(0, 12) + "...",
+          Depth: ch.depth,
+          "World Line": ch.is_world_line ? "Yes" : "No",
+          Length: ch.declared_length
+        }))
+      );
+      console.log();
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  chapter.command("context <chapter-id>").description(
+    "Fetch the full ancestor chain (root \u2192 target). Essential for evaluating a candidate chapter before voting or continuing the story \u2014 gives you the complete narrative so far."
+  ).option("--max-depth <n>", "max ancestors to walk back", "100").option("--summary", "print only metadata; skip full content").option(
+    "--cache <dir>",
+    "also write each ancestor's content to <dir>/<id>.md and a TODO notes skeleton to <dir>/<id>-ch<depth>-<parentId>.md. Existing files are NOT overwritten."
+  ).action(async (chapterId, opts) => {
+    try {
+      const maxDepth = Math.min(parseInt(opts.maxDepth) || 100, 200);
+      const data = await apiGet(
+        `/api/chapters/${chapterId}/context?maxDepth=${maxDepth}`
+      );
+      header(`Context for Chapter ID.${chapterId}`);
+      kv("Ancestors", data.ancestors.length);
+      if (opts.cache) {
+        mkdirSync(opts.cache, { recursive: true });
+        let wrote = 0;
+        let skipped = 0;
+        let skeletonsAdded = 0;
+        for (const a of data.ancestors) {
+          const id = String(a.id);
+          const depth = String(a.depth);
+          const parentId = String(a.parent_id ?? "0");
+          const contentPath = join2(opts.cache, `${id}.md`);
+          if (!existsSync2(contentPath)) {
+            if (a.content_text) {
+              writeFileSync(contentPath, String(a.content_text));
+              wrote++;
+            }
+          } else {
+            skipped++;
+          }
+          const notesPath = join2(opts.cache, `${id}-ch${depth}-${parentId}.md`);
+          if (!existsSync2(notesPath)) {
+            writeFileSync(notesPath, renderNotesSkeleton(id, depth, parentId));
+            skeletonsAdded++;
+          }
+        }
+        kv("Cached content", `${wrote} new, ${skipped} existing (preserved)`);
+        kv("Notes skeletons", `${skeletonsAdded} new (TODO \u2014 fill before drafting)`);
+        kv("Cache dir", opts.cache);
+      }
+      if (opts.summary) {
+        table(
+          data.ancestors.map((a) => ({
+            Chapter: `ID.${a.id}`,
+            Depth: a.depth,
+            Author: String(a.author ?? "").slice(0, 12) + "...",
+            WorldLine: a.is_world_line ? "yes" : "no",
+            Fetched: a.content_fetched ? "yes" : "no"
+          }))
+        );
+        console.log();
+        return;
+      }
+      for (const a of data.ancestors) {
+        console.log(
+          chalk3.gray(`
+\u2500\u2500\u2500 Chapter ID.${a.id} (depth ${a.depth}, by ${String(a.author ?? "").slice(0, 10)}...) \u2500\u2500\u2500`)
+        );
+        if (a.content_text) {
+          console.log(String(a.content_text));
+        } else if (a.content_fetched === false) {
+          console.log(chalk3.yellow("  (content not yet indexed)"));
+        } else {
+          console.log(chalk3.gray("  (no content)"));
+        }
+      }
+      console.log();
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  chapter.command("comments <chapter-id>").description("List comments on a chapter").option("--page <n>", "page number", "1").option("--limit <n>", "results per page", "20").action(async (chapterId, opts) => {
+    try {
+      const data = await apiGet(
+        `/api/chapters/${chapterId}/comments?page=${opts.page}&limit=${opts.limit}`
+      );
+      header(`Comments on Chapter ID.${chapterId}`);
+      if (data.comments.length === 0) {
+        console.log(chalk3.gray("  (no comments)\n"));
+        return;
+      }
+      for (const c of data.comments) {
+        console.log(
+          `${chalk3.cyan(String(c.author ?? "").slice(0, 12) + "...")} ` + chalk3.gray(`#${c.id} ${c.created_at}`)
+        );
+        console.log(`  ${c.content}
+`);
+      }
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  chapter.command("comment <chapter-id> <content>").description("Post an off-chain comment (EIP-191 signed, no on-chain tx)").action(async (chapterId, content) => {
+    try {
+      const client2 = getWalletClient();
+      const address = client2.account.address;
+      const ts = Math.floor(Date.now() / 1e3);
+      const message = `Comment on chapter ${chapterId} at ${ts}: ${content}`;
+      const signature = await client2.signMessage({ account: client2.account, message });
+      const result = await apiPost(`/api/chapters/${chapterId}/comments`, {
+        address,
+        content,
+        timestamp: ts,
+        signature
+      });
+      if (result.status === 201 && result.body?.id) {
+        success(`Comment posted (id=${result.body.id})`);
+      } else {
+        error(`Backend rejected comment (status ${result.status})`);
+        process.exit(1);
+      }
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/config.ts
+function registerConfigCommand(program2) {
+  program2.command("config").description(
+    "Show current configuration. Edit config.yaml (repo root) directly to change values. Secrets (PRIVATE_KEY, KEEPER_PRIVATE_KEY, VOTE_ENCRYPTION_KEY) stay in env vars."
+  ).action(async () => {
+    try {
+      const { config, chainId, contracts } = await bootstrapConfig();
+      header("Configuration");
+      kv("chain.rpcUrl", config.chain.rpcUrl);
+      kv("chain.chainId", chainId);
+      kv("cli.apiUrl", config.cli.apiUrl);
+      kv("PRIVATE_KEY env", process.env.PRIVATE_KEY ? "(set)" : "(not set)");
+      kv("contracts.novelCore", contracts.novelCore);
+      kv("contracts.roundManager", contracts.roundManager);
+      kv("contracts.votingEngine", contracts.votingEngine);
+      kv("contracts.prizePool", contracts.prizePool);
+      kv("contracts.bountyBoard", contracts.bountyBoard);
+      kv("contracts.rulesEngine", contracts.rulesEngine);
+      kv("contracts.userRegistry", contracts.userRegistry);
+      console.log();
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/faucet.ts
+import { isAddress } from "viem";
+import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+function resolveSelfAddress() {
+  const pk = getPrivateKey2();
+  if (!pk) {
+    error(
+      "No --address given and PRIVATE_KEY env not set. Either pass --address 0x... or export PRIVATE_KEY."
+    );
+    process.exit(1);
+  }
+  return privateKeyToAccount2(pk).address;
+}
+function formatHms(ms) {
+  const total = Math.max(0, Math.floor(ms / 1e3));
+  const h = Math.floor(total / 3600);
+  const m = Math.floor(total % 3600 / 60);
+  const s = total % 60;
+  return `${h}h${m}m${s}s`;
+}
+function registerFaucetCommands(program2) {
+  const faucet = program2.command("faucet").description("Testnet faucet \u2014 claim native tokens to fund chain commands");
+  faucet.command("claim").description(
+    "Claim 10 native tokens from the backend faucet. One claim per address per local day. Defaults to the PRIVATE_KEY wallet."
+  ).option("--address <addr>", "address to fund (defaults to PRIVATE_KEY wallet)").action(async (opts) => {
+    try {
+      let target;
+      if (opts.address) {
+        if (!isAddress(opts.address)) {
+          error(`Not a valid address: ${opts.address}`);
+          process.exit(1);
+        }
+        target = opts.address;
+      } else {
+        target = resolveSelfAddress();
+      }
+      header("Faucet \u2014 claim");
+      kv("Address", target);
+      const { status, body } = await apiPost("/api/faucet/claim", {
+        address: target
+      });
+      if (body?.txHash) {
+        txHash(body.txHash);
+        success(`Sent ${body.amount} ${body.symbol} to ${body.to}`);
+        return;
+      }
+      const msg = body?.error ?? `HTTP ${status}`;
+      error(
+        status === 429 && body?.nextResetMs ? `${msg} (resets in ${formatHms(body.nextResetMs)})` : msg
+      );
+      process.exit(1);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/guide.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname2, join as join3 } from "path";
+import { fileURLToPath } from "url";
+function getSkillPath() {
+  const here = dirname2(fileURLToPath(import.meta.url));
+  return existsSync3(join3(here, "guides")) ? join3(here, "guides", "SKILL.md") : join3(here, "..", "guides", "SKILL.md");
+}
+function registerGuideCommands(program2) {
+  program2.command("guide").description("Print the agent workflow guide (covers reader / voter / author / creator)").action(() => {
+    try {
+      console.log(readFileSync3(getSkillPath(), "utf-8"));
+    } catch (err) {
+      error(`Could not load guide. ${String(err)}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/novel.ts
+init_shared();
+import { parseEther as parseEther3 } from "viem";
+function buildNovelConfig(opts) {
+  return {
+    minChapterLength: BigInt(opts.minLength ?? "1000"),
+    maxChapterLength: BigInt(opts.maxLength ?? "50000"),
+    submissionFee: parseEther3(opts.submissionFee ?? "0.001"),
+    worldLineCount: parseInt(opts.worldLines ?? "3"),
+    voteStake: parseEther3(opts.voteStake ?? "0.001"),
+    nominationFee: parseEther3(opts.nominationFee ?? "0.1"),
+    nominateDuration: BigInt(opts.nominateDuration ?? "3600"),
+    commitDuration: BigInt(opts.commitDuration ?? "3600"),
+    revealDuration: BigInt(opts.revealDuration ?? "3600"),
+    minRoundGap: BigInt(opts.minRoundGap ?? "60"),
+    prizeReleaseRate: parseInt(opts.prizeReleaseRate ?? "2000"),
+    voterRewardRate: parseInt(opts.voterRewardRate ?? "500"),
+    contentLocation: parseInt(opts.contentLocation ?? "0"),
+    contentBaseUrl: opts.contentBaseUrl ?? "",
+    ruleFee: parseEther3(opts.ruleFee ?? "0.01"),
+    ruleVoteDuration: BigInt(opts.ruleVoteDuration ?? "86400"),
+    ruleQuorum: parseInt(opts.ruleQuorum ?? "3")
+  };
+}
+function buildMetadata(opts) {
+  return {
+    title: opts.title ?? "Untitled Novel",
+    description: opts.description ?? "",
+    coverUri: opts.coverUri ?? ""
+  };
+}
+function registerNovelCommands(program2) {
+  const novel = program2.command("novel").description("Novel management commands");
+  novel.command("create").description("Create a new novel with a root chapter").option("--title <text>", "novel title", "Untitled Novel").option("--description <text>", "novel description", "").option("--cover-uri <uri>", "cover image URI", "").option("--min-length <n>", "min chapter length", "100").option("--max-length <n>", "max chapter length", "50000").option("--submission-fee <eth>", "submission fee in ETH", "0.001").option("--world-lines <n>", "world line count", "3").option("--vote-stake <eth>", "vote stake in ETH (must be <= submission fee)", "0.001").option("--nomination-fee <eth>", "nomination fee in ETH", "0.01").option("--nominate-duration <s>", "nominate duration in seconds", "3600").option("--commit-duration <s>", "commit duration in seconds", "3600").option("--reveal-duration <s>", "reveal duration in seconds", "3600").option("--min-round-gap <s>", "min round gap in seconds", "60").option("--prize-release-rate <bps>", "prize release rate in basis points", "2000").option("--voter-reward-rate <bps>", "voter reward rate in basis points", "1500").option("--content-location <n>", "0=Onchain, 1=External, 2=HTTP", "0").option("--content-base-url <url>", "content base URL (for External/HTTP)", "").option("--rule-fee <eth>", "rule proposal fee in ETH", "0.01").option("--rule-vote-duration <s>", "rule vote duration in seconds", "86400").option("--rule-quorum <n>", "rule quorum", "3").option("--content <text>", "root chapter content (mutually exclusive with --file)").option("--file <path>", "read root chapter content from a UTF-8 text file").option("--value <eth>", "genesis fund in ETH", "0").action(async (opts) => {
+    try {
+      const client2 = getWalletClient();
+      const contracts = getContracts();
+      const config = buildNovelConfig(opts);
+      const metadata = buildMetadata(opts);
+      const content = resolveContent(opts);
+      warnIfOutOfRange(content, {
+        minChapterLength: config.minChapterLength.toString(),
+        maxChapterLength: config.maxChapterLength.toString()
+      });
+      const submission = buildContentSubmission(content);
+      const submissionFee = config.submissionFee;
+      const extraValue = parseEther3(opts.value ?? "0");
+      const totalValue = submissionFee + extraValue;
+      const hash = await createNovel(client2, {
+        config,
+        metadata,
+        rootChapter: submission,
+        value: totalValue,
+        novelCore: contracts.novelCore
+      });
+      txHash(hash);
+      await waitForTx(hash);
+      success("Novel created successfully");
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  novel.command("info <id>").description("Show novel details").action(async (id) => {
+    try {
+      const { nativeCurrency } = requireConfig();
+      const data = await apiGet(`/api/novels/${id}`);
+      header(`Novel #${id}`);
+      kv("Title", data.title);
+      kv("Creator", data.creator);
+      kv("Description", data.description || "(none)");
+      kv("Active", data.active);
+      kv("Current Round", data.current_round);
+      kv("Round Phase", roundPhaseName(Number(data.round_phase)));
+      kv("Pool Balance", token(BigInt(String(data.pool_balance ?? "0")), nativeCurrency.decimals, nativeCurrency.symbol));
+      kv("Total Tipped", token(BigInt(String(data.total_tipped ?? "0")), nativeCurrency.decimals, nativeCurrency.symbol));
+      kv("Chapters", data.chapter_count);
+      kv("Authors", data.author_count);
+      kv("Views", data.view_count);
+      kv("Created", data.created_at);
+      console.log();
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  novel.command("list").description("List novels").option("--sort <field>", "sort by: hot, pool, tipped, active, latest", "latest").option("--limit <n>", "results per page", "10").option("--page <n>", "page number", "1").option("--filter <status>", "filter by: active, completed").option(
+    "--search <query>",
+    "search by title/description substring, novel id, or creator address (0x...)"
+  ).action(async (opts) => {
+    try {
+      const { nativeCurrency } = requireConfig();
+      const params = new URLSearchParams();
+      params.set("sort", opts.sort);
+      params.set("limit", opts.limit);
+      params.set("page", opts.page);
+      if (opts.filter) params.set("filter", opts.filter);
+      if (opts.search) params.set("search", opts.search);
+      const data = await apiGet(`/api/novels?${params.toString()}`);
+      header("Novels");
+      table(
+        data.novels.map((n) => ({
+          ID: n.id,
+          Title: String(n.title ?? "").slice(0, 30),
+          Creator: String(n.creator ?? "").slice(0, 10) + "...",
+          Active: n.active ? "Yes" : "No",
+          Round: n.current_round,
+          Chapters: n.chapter_count,
+          Pool: token(BigInt(String(n.pool_balance ?? "0")), nativeCurrency.decimals, nativeCurrency.symbol)
+        }))
+      );
+      const p = data.pagination;
+      console.log(`
+  Page ${p.page}/${p.totalPages} (${p.total} total)
+`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  novel.command("fork <chapter-id>").description("Fork a novel from a specific chapter").option("--title <text>", "novel title", "Untitled Fork").option("--description <text>", "novel description", "").option("--cover-uri <uri>", "cover image URI", "").option("--min-length <n>", "min chapter length", "100").option("--max-length <n>", "max chapter length", "50000").option("--submission-fee <eth>", "submission fee in ETH", "0.001").option("--world-lines <n>", "world line count", "3").option("--vote-stake <eth>", "vote stake in ETH (must be <= submission fee)", "0.001").option("--nomination-fee <eth>", "nomination fee in ETH", "0.01").option("--nominate-duration <s>", "nominate duration in seconds", "3600").option("--commit-duration <s>", "commit duration in seconds", "3600").option("--reveal-duration <s>", "reveal duration in seconds", "3600").option("--min-round-gap <s>", "min round gap in seconds", "60").option("--prize-release-rate <bps>", "prize release rate in basis points", "2000").option("--voter-reward-rate <bps>", "voter reward rate in basis points", "1500").option("--content-location <n>", "0=Onchain, 1=External, 2=HTTP", "0").option("--content-base-url <url>", "content base URL", "").option("--rule-fee <eth>", "rule proposal fee in ETH", "0.01").option("--rule-vote-duration <s>", "rule vote duration in seconds", "86400").option("--rule-quorum <n>", "rule quorum", "3").option("--content <text>", "fork root chapter content (mutually exclusive with --file)").option("--file <path>", "read fork root chapter content from a UTF-8 text file").option("--value <eth>", "genesis fund in ETH", "0").action(async (chapterId, opts) => {
+    try {
+      const client2 = getWalletClient();
+      const contracts = getContracts();
+      const config = buildNovelConfig(opts);
+      const metadata = buildMetadata(opts);
+      const content = resolveContent(opts);
+      warnIfOutOfRange(content, {
+        minChapterLength: config.minChapterLength.toString(),
+        maxChapterLength: config.maxChapterLength.toString()
+      });
+      const submission = buildContentSubmission(content);
+      const extraValue = parseEther3(opts.value ?? "0");
+      const totalValue = config.submissionFee + extraValue;
+      const hash = await forkNovel(client2, {
+        sourceChapterId: BigInt(chapterId),
+        config,
+        metadata,
+        rootChapter: submission,
+        value: totalValue,
+        novelCore: contracts.novelCore
+      });
+      txHash(hash);
+      await waitForTx(hash);
+      success("Novel forked successfully");
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  novel.command("update-metadata <id>").description("Update novel title / description / coverUri (creator only)").option("--title <text>", "new title").option("--description <text>", "new description").option("--cover-uri <uri>", "new cover image URI").action(async (id, opts) => {
+    try {
+      if (!opts.title && !opts.description && opts.coverUri === void 0) {
+        error("Pass at least one of --title, --description, --cover-uri.");
+        return process.exit(1);
+      }
+      const client2 = getWalletClient();
+      const contracts = getContracts();
+      const current = await apiGet(`/api/novels/${id}`);
+      const metadata = {
+        title: opts.title ?? String(current.title ?? ""),
+        description: opts.description ?? String(current.description ?? ""),
+        coverUri: opts.coverUri ?? String(current.cover_uri ?? "")
+      };
+      const hash = await updateNovelMetadata(client2, {
+        novelId: BigInt(id),
+        metadata,
+        novelCore: contracts.novelCore
+      });
+      txHash(hash);
+      await waitForTx(hash);
+      success("Novel metadata updated");
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  novel.command("complete <id>").description(
+    "Complete a novel (creator / keeper / owner, or anyone after inactivity timeout). Final-path author derivation happens fully on-chain via NovelCore.collectPathAuthors."
+  ).action(async (id) => {
+    try {
+      const client2 = getWalletClient();
+      const contracts = getContracts();
+      const hash = await completeNovel(client2, {
+        novelId: BigInt(id),
+        roundManager: contracts.roundManager
+      });
+      txHash(hash);
+      await waitForTx(hash);
+      success("Novel completed");
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/rule.ts
+init_shared();
+import chalk4 from "chalk";
+import { parseEther as parseEther4 } from "viem";
+function registerRuleCommands(program2) {
+  const rule = program2.command("rule").description("World-building rules commands");
+  rule.command("list <novel-id>").description("List all rules for a novel").action(async (novelId) => {
+    try {
+      const client2 = getPublicClient();
+      const rulesEngine = getContracts().rulesEngine;
+      const names = await getRuleNames(client2, BigInt(novelId), rulesEngine);
+      header(`Rules \u2014 Novel #${novelId}`);
+      if (names.length === 0) {
+        console.log(chalk4.gray("  (no rules set)"));
+        console.log();
+        return;
+      }
+      for (const name of names) {
+        const content = await getRule(client2, BigInt(novelId), name, rulesEngine);
+        console.log(chalk4.bold(`  ${name}:`));
+        console.log(`    ${content}`);
+        console.log();
+      }
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  rule.command("set <novel-id> <name> <content>").description("Set a creator rule (only before first round, creator only)").action(async (novelId, name, content) => {
+    try {
+      const client2 = getWalletClient();
+      const rulesEngine = getContracts().rulesEngine;
+      const hash = await setCreatorRules(client2, {
+        novelId: BigInt(novelId),
+        names: [name],
+        contents: [content],
+        rulesEngine
+      });
+      txHash(hash);
+      await waitForTx(hash);
+      success(`Rule "${name}" set`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  rule.command("propose <novel-id> <action> <name> <chapter-id> [content]").description(
+    "Propose adding or deleting a rule (action: add|delete). <chapter-id> is one of your authored chapters that's currently on a world line \u2014 the path proof is computed automatically."
+  ).option("--value <eth>", "rule proposal fee in ETH").action(async (novelId, action, name, chapterId, content, opts) => {
+    try {
+      if (action !== "add" && action !== "delete") {
+        error("Action must be 'add' or 'delete'");
+        return process.exit(1);
+      }
+      if (action === "add" && !content) {
+        error("Content is required for 'add' proposals");
+        return process.exit(1);
+      }
+      const wallet = getWalletClient();
+      const pub = getPublicClient();
+      const contracts = getContracts();
+      const rulesEngine = contracts.rulesEngine;
+      let value;
+      if (opts.value) {
+        value = parseEther4(opts.value);
+      } else {
+        const { config } = await fetchNovelConfig(novelId);
+        value = BigInt(config.ruleFee ?? "0");
+      }
+      const path = await buildWorldLineProof(
+        pub,
+        contracts.novelCore,
+        BigInt(novelId),
+        BigInt(chapterId)
+      );
+      if (!path) {
+        error(`Chapter ID.${chapterId} is not currently on any world line of novel #${novelId}.`);
+        return process.exit(1);
+      }
+      const proposalType = action === "add" ? 0 : 1;
+      const hash = await proposeRule(wallet, {
+        novelId: BigInt(novelId),
+        proposalType,
+        ruleName: name,
+        ruleContent: content ?? "",
+        path,
+        value,
+        rulesEngine
+      });
+      txHash(hash);
+      await waitForTx(hash);
+      success(`Rule proposal created: ${action} "${name}"`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  rule.command("vote <proposal-id> <chapter-id>").description(
+    "Vote on a rule proposal. <chapter-id> is one of your authored chapters that's currently on a world line \u2014 the path proof is computed automatically."
+  ).action(async (proposalId, chapterId) => {
+    try {
+      const wallet = getWalletClient();
+      const pub = getPublicClient();
+      const contracts = getContracts();
+      const rulesEngine = contracts.rulesEngine;
+      const proposal = await getRuleProposal(pub, BigInt(proposalId), rulesEngine);
+      const path = await buildWorldLineProof(
+        pub,
+        contracts.novelCore,
+        proposal.novelId,
+        BigInt(chapterId)
+      );
+      if (!path) {
+        error(
+          `Chapter ID.${chapterId} is not currently on any world line of novel #${proposal.novelId}.`
+        );
+        return process.exit(1);
+      }
+      const hash = await voteOnRuleProposal(wallet, {
+        proposalId: BigInt(proposalId),
+        path,
+        rulesEngine
+      });
+      txHash(hash);
+      await waitForTx(hash);
+      success("Voted on rule proposal");
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  rule.command("proposal <proposal-id>").description("Show details of a rule proposal").action(async (proposalId) => {
+    try {
+      const client2 = getPublicClient();
+      const rulesEngine = getContracts().rulesEngine;
+      const proposal = await getRuleProposal(client2, BigInt(proposalId), rulesEngine);
+      header(`Rule Proposal #${proposalId}`);
+      kv("Novel", proposal.novelId.toString());
+      kv("Proposer", proposal.proposer);
+      kv("Type", proposal.proposalType === 0 ? "Add" : "Delete");
+      kv("Rule Name", proposal.ruleName);
+      if (proposal.ruleContent) {
+        kv("Rule Content", proposal.ruleContent);
+      }
+      kv("Vote Count", proposal.voteCount.toString());
+      kv("Executed", proposal.executed ? "Yes" : "No");
+      kv("Created At", new Date(Number(proposal.createdAt) * 1e3).toISOString());
+      console.log();
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/setup.ts
+init_shared();
+import { chmodSync, existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname3, join as join4 } from "path";
+import { stdin, stdout } from "process";
+import { createInterface } from "readline/promises";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import {
+  createPublicClient as createPublicClient4,
+  createWalletClient as createWalletClient2,
+  defineChain as defineChain2,
+  http as http4,
+  pad,
+  stringToHex
+} from "viem";
+import { generatePrivateKey, privateKeyToAccount as privateKeyToAccount3 } from "viem/accounts";
+import { parse as yamlParse, stringify as yamlStringify } from "yaml";
+import { z as z2 } from "zod";
+async function prompt(rl, question, defaultValue) {
+  const answer = await rl.question(`${question} [${defaultValue}]: `);
+  return answer.trim() || defaultValue;
+}
+var ADDRESS_RE = /^0x[0-9a-fA-F]{40}$/;
+var SetupConfigSchema = z2.object({
+  chain: z2.object({
+    rpcUrl: z2.string().url(),
+    nativeCurrency: z2.object({
+      name: z2.string(),
+      symbol: z2.string(),
+      decimals: z2.number().int().positive()
+    })
+  }).passthrough(),
+  contracts: z2.object({
+    novelCore: z2.string().regex(ADDRESS_RE).transform((s) => s)
+  }).passthrough(),
+  cli: z2.object({
+    apiUrl: z2.string().url()
+  }).passthrough()
+}).passthrough();
+function resolveGuidesDir(here) {
+  const candidates = [join4(here, "guides"), join4(here, "..", "guides")];
+  const dir = candidates.find((candidate) => existsSync4(candidate));
+  if (!dir) throw new Error("Could not locate bundled guides directory for setup");
+  return dir;
+}
+function resolveConfigExamplePath(here) {
+  const candidates = [
+    join4(here, "config.yaml.example"),
+    join4(here, "..", "..", "config.yaml.example"),
+    join4(here, "..", "..", "..", "config.yaml.example")
+  ];
+  const path = candidates.find((candidate) => existsSync4(candidate));
+  if (!path) throw new Error("Could not locate bundled config.yaml.example for setup");
+  return path;
+}
+function loadSetupDefaults(here) {
+  const path = resolveConfigExamplePath(here);
+  return SetupConfigSchema.parse(yamlParse(readFileSync4(path, "utf-8")));
+}
+function renderConfig(config) {
+  return `# Generated by \`onchain-novel-cli setup\`.
+# Non-secret settings only. Secrets (PRIVATE_KEY, KEEPER_PRIVATE_KEY,
+# VOTE_ENCRYPTION_KEY) belong in env vars, never here.
+#
+# Defaults are sourced from \`config.yaml.example\` bundled with this CLI.
+# Edit any of the values below to match your deployment.
+
+${yamlStringify(config)}`;
+}
+function nicknameToBytes32(nickname) {
+  return pad(stringToHex(nickname), { size: 32, dir: "right" });
+}
+function appendGitignore(line) {
+  const path = join4(process.cwd(), ".gitignore");
+  let body = existsSync4(path) ? readFileSync4(path, "utf-8") : "";
+  if (body.split("\n").some((l) => l.trim() === line)) return;
+  if (body.length > 0 && !body.endsWith("\n")) body += "\n";
+  body += line + "\n";
+  writeFileSync2(path, body);
+}
+async function createIdentity(nickname) {
+  header(`Identity \u2014 ${nickname}`);
+  const privateKey = generatePrivateKey();
+  const account = privateKeyToAccount3(privateKey);
+  const address = account.address;
+  const identityPath = join4(process.cwd(), "identity.yaml");
+  const banner = "# WARNING: contains a private key. File mode is 0600. Do not commit.\n# After memorising the key, prefer `export PRIVATE_KEY=...` then `rm identity.yaml`.\n";
+  writeFileSync2(identityPath, banner + yamlStringify({ nickname, address, privateKey }), {
+    mode: 384
+  });
+  chmodSync(identityPath, 384);
+  appendGitignore("identity.yaml");
+  success("Wrote identity.yaml (mode 0600)");
+  kv("Address", address);
+  try {
+    await ensureBootstrapped();
+  } catch (err) {
+    error(`Bootstrap failed: ${String(err)}`);
+    console.log(
+      `  Once the chain is reachable, run (with PRIVATE_KEY exported from identity.yaml):
+    onchain-novel-cli faucet claim
+    onchain-novel-cli user set-nickname ${nickname}
+`
+    );
+    return;
+  }
+  const cfg = requireConfig();
+  const chain = defineChain2({
+    id: cfg.chainId,
+    name: `Chain ${cfg.chainId}`,
+    nativeCurrency: cfg.nativeCurrency,
+    rpcUrls: { default: { http: [cfg.rpcUrl] } }
+  });
+  const pub = createPublicClient4({ chain, transport: http4(cfg.rpcUrl) });
+  const wallet = createWalletClient2({ account, chain, transport: http4(cfg.rpcUrl) });
+  let faucetTx;
+  try {
+    const { status, body } = await apiPost("/api/faucet/claim", { address });
+    if (!body?.txHash) {
+      error(`Faucet claim failed: ${body?.error ?? `HTTP ${status}`}`);
+      console.log("  Retry: onchain-novel-cli faucet claim\n");
+      return;
+    }
+    faucetTx = body.txHash;
+    txHash(faucetTx);
+    success(`Faucet sent ${body.amount} ${body.symbol}`);
+  } catch (err) {
+    error(`Faucet API call failed: ${String(err)}`);
+    console.log("  Retry: onchain-novel-cli faucet claim\n");
+    return;
+  }
+  try {
+    await pub.waitForTransactionReceipt({ hash: faucetTx });
+  } catch (err) {
+    error(`Faucet tx broadcast but not yet confirmed: ${String(err)}`);
+    console.log(
+      `  Once the tx lands, run: onchain-novel-cli user set-nickname ${nickname}
+`
+    );
+    return;
+  }
+  try {
+    const hash = await setNickname(
+      wallet,
+      nicknameToBytes32(nickname),
+      cfg.contracts.userRegistry
+    );
+    txHash(hash);
+    await pub.waitForTransactionReceipt({ hash });
+    success(`Nickname registered on-chain: ${nickname}`);
+  } catch (err) {
+    error(`setNickname failed: ${String(err)}`);
+    console.log(`  Retry: onchain-novel-cli user set-nickname ${nickname}
+`);
+  }
+}
+function registerSetupCommand(program2) {
+  program2.command("setup").description(
+    "Generate config.yaml plus a workflow skill for onchain-novel-cli. Writes the skill to .agent/skills/onchain-novel/SKILL.md AND .claude/commands/onchain-novel.md (so any agent can find it), and drops onchain-novel-index.md at the project root as a discovery hint."
+  ).option(
+    "--full",
+    "Interactive full setup: prompt for Ethereum RPC URL, Backend API URL, NovelCore proxy address, Frontend base URL, and Chain Explorer base URL. Without this flag, defaults from config.yaml.example are used without prompting."
+  ).action(async (options) => {
+    try {
+      header("Onchain Novel CLI Setup");
+      const here = dirname3(fileURLToPath2(import.meta.url));
+      const guidesDir = resolveGuidesDir(here);
+      const defaults = loadSetupDefaults(here);
+      const skillContent = readFileSync4(join4(guidesDir, "SKILL.md"), "utf-8");
+      const indexContent = readFileSync4(join4(guidesDir, "onchain-novel-index.md"), "utf-8");
+      const targets = [
+        {
+          dir: join4(process.cwd(), ".agent", "skills", "onchain-novel"),
+          file: "SKILL.md",
+          content: skillContent,
+          label: ".agent/skills/onchain-novel/SKILL.md"
+        },
+        {
+          dir: join4(process.cwd(), ".claude", "commands"),
+          file: "onchain-novel.md",
+          content: skillContent,
+          label: ".claude/commands/onchain-novel.md"
+        },
+        {
+          dir: process.cwd(),
+          file: "onchain-novel-index.md",
+          content: indexContent,
+          label: "onchain-novel-index.md"
+        }
+      ];
+      for (const t of targets) {
+        if (!existsSync4(t.dir)) mkdirSync2(t.dir, { recursive: true });
+        writeFileSync2(join4(t.dir, t.file), t.content);
+        success(`Generated ${t.label}`);
+      }
+      const configPath = join4(process.cwd(), "config.yaml");
+      if (existsSync4(configPath)) {
+        console.log(
+          `
+config.yaml already exists at ${configPath} -- keeping it. Delete it first if you want to regenerate.`
+        );
+        return;
+      }
+      const setupConfig = structuredClone(defaults);
+      const DEFAULT_RPC = defaults.chain.rpcUrl;
+      const DEFAULT_API = defaults.cli.apiUrl;
+      const DEFAULT_NOVEL_CORE = defaults.contracts.novelCore;
+      const DEFAULT_FRONT_URL = defaults.cli.frontUrl;
+      const DEFAULT_EXPLORER = defaults.cli.chainExplorer;
+      let identityNickname = null;
+      if (stdin.isTTY) {
+        const rl = createInterface({ input: stdin, output: stdout });
+        try {
+          if (options.full) {
+            console.log(
+              "\nGenerating config.yaml (full mode). Press Enter to accept defaults where shown.\nDefaults are loaded from the bundled config.yaml.example.\n"
+            );
+            setupConfig.chain.rpcUrl = await prompt(rl, "BlockChain RPC URL", DEFAULT_RPC);
+            setupConfig.cli.apiUrl = await prompt(rl, "Backend API URL", DEFAULT_API);
+            while (true) {
+              const answer = await prompt(rl, "NovelCore proxy address (0x...)", DEFAULT_NOVEL_CORE);
+              if (ADDRESS_RE.test(answer)) {
+                setupConfig.contracts.novelCore = answer;
+                break;
+              }
+              console.log("  not a 0x-prefixed 20-byte hex address -- try again");
+            }
+            setupConfig.cli.frontUrl = await prompt(
+              rl,
+              "Frontend base URL (chapter paths appended at runtime)",
+              DEFAULT_FRONT_URL
+            );
+            setupConfig.cli.chainExplorer = await prompt(
+              rl,
+              "Chain explorer base URL (/tx/{hash} appended at runtime)",
+              DEFAULT_EXPLORER
+            );
+          }
+          const identityPath = join4(process.cwd(), "identity.yaml");
+          if (existsSync4(identityPath)) {
+            console.log(
+              `
+identity.yaml already exists -- skipping identity creation.
+  Delete it first if you want a fresh wallet.`
+            );
+          } else {
+            const create = (await prompt(rl, "Create a new wallet for quick start [Y] / Use existing PRIVATE_KEY env [n]", "Y")).toLowerCase();
+            if (create === "y" || create === "yes") {
+              console.log(
+                "  Nickname is registered ON-CHAIN, ONE-TIME, and IMMUTABLE.\n  Limit: \u2264 32 UTF-8 bytes."
+              );
+              while (true) {
+                const nick = (await rl.question("Pick a nickname: ")).trim();
+                if (nick.length === 0) {
+                  console.log("  nickname cannot be empty -- try again");
+                  continue;
+                }
+                const bytes = Buffer.byteLength(nick, "utf-8");
+                if (bytes > 32) {
+                  console.log(`  too long (${bytes} bytes) -- max 32 UTF-8 bytes`);
+                  continue;
+                }
+                identityNickname = nick;
+                break;
+              }
+            }
+          }
+        } finally {
+          rl.close();
+        }
+      } else {
+        console.log(
+          `
+Non-interactive stdin -- writing config.yaml with bundled defaults (rpcUrl=${DEFAULT_RPC}, apiUrl=${DEFAULT_API}, novelCore=${DEFAULT_NOVEL_CORE}).
+Edit config.yaml before running any chain command if you need a different deployment.`
+        );
+      }
+      writeFileSync2(configPath, renderConfig(setupConfig));
+      success(`Wrote ${configPath}`);
+      if (identityNickname) {
+        await createIdentity(identityNickname);
+      }
+      console.log(
+        "\nNext steps:\n  - Edit config.yaml if anything's wrong.\n" + (identityNickname ? "  - Read identity.yaml for your wallet. To harden, run\n      export PRIVATE_KEY=0x...   # paste the privateKey from identity.yaml\n      rm identity.yaml           # avoid leaking the key on disk\n" : "  - export PRIVATE_KEY=0x... before running write commands.\n")
+      );
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/tip.ts
+init_shared();
+import { parseEther as parseEther5 } from "viem";
+function registerTipCommands(program2) {
+  const tip = program2.command("tip").description("Tip novels or chapters");
+  tip.command("novel <novel-id>").description("Tip a novel").requiredOption("--value <eth>", "tip amount in ETH").action(async (novelId, opts) => {
+    try {
+      const client2 = getWalletClient();
+      const contracts = getContracts();
+      const hash = await tipNovel(client2, {
+        id: BigInt(novelId),
+        value: parseEther5(opts.value),
+        prizePool: contracts.prizePool
+      });
+      txHash(hash);
+      await waitForTx(hash);
+      success(`Tipped novel #${novelId} with ${opts.value} ETH`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  tip.command("chapter <chapter-id>").description("Tip a chapter (50% to author, 50% to prize pool)").requiredOption("--value <eth>", "tip amount in ETH").action(async (chapterId, opts) => {
+    try {
+      const client2 = getWalletClient();
+      const contracts = getContracts();
+      const hash = await tipChapter(client2, {
+        id: BigInt(chapterId),
+        value: parseEther5(opts.value),
+        prizePool: contracts.prizePool
+      });
+      txHash(hash);
+      await waitForTx(hash);
+      success(`Tipped chapter ID.${chapterId} with ${opts.value} ETH`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  tip.command("claim <novel-id>").description("Claim accumulated author/creator rewards").action(async (novelId) => {
+    try {
+      const client2 = getWalletClient();
+      const contracts = getContracts();
+      const hash = await claimReward(client2, BigInt(novelId), contracts.novelCore);
+      txHash(hash);
+      await waitForTx(hash);
+      success("Rewards claimed");
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/user.ts
+init_shared();
+import { hexToString, pad as pad2, stringToHex as stringToHex2 } from "viem";
+import { privateKeyToAccount as privateKeyToAccount4 } from "viem/accounts";
+function nicknameToBytes322(nickname) {
+  const bytes = Buffer.byteLength(nickname, "utf-8");
+  if (bytes === 0) throw new Error("Nickname cannot be empty.");
+  if (bytes > 32) throw new Error(`Nickname must be \u2264 32 UTF-8 bytes (got ${bytes}).`);
+  return pad2(stringToHex2(nickname), { size: 32, dir: "right" });
+}
+function resolveAddress(argAddr) {
+  if (argAddr) return argAddr.toLowerCase();
+  const pk = getPrivateKey2();
+  if (!pk) {
+    error(
+      "No address given and PRIVATE_KEY env not set. Either pass an address or export PRIVATE_KEY."
+    );
+    process.exit(1);
+  }
+  return privateKeyToAccount4(pk).address.toLowerCase();
+}
+function registerUserCommands(program2) {
+  const user = program2.command("user").description("Query user (address) activity");
+  user.command("set-nickname <nickname>").description(
+    "Register a one-time, immutable on-chain nickname (\u226432 UTF-8 bytes). Cannot be changed once set."
+  ).action(async (nickname) => {
+    try {
+      const contracts = getContracts();
+      const bytes32 = nicknameToBytes322(nickname);
+      const client2 = getWalletClient();
+      const hash = await setNickname(client2, bytes32, contracts.userRegistry);
+      txHash(hash);
+      await waitForTx(hash);
+      success(`Nickname set: ${nickname}`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  user.command("nickname [address]").description("Show the on-chain nickname for an address (defaults to PRIVATE_KEY wallet).").action(async (addrArg) => {
+    try {
+      const contracts = getContracts();
+      const addr = resolveAddress(addrArg);
+      const pub = getPublicClient();
+      const raw = await getNickname(pub, addr, contracts.userRegistry);
+      const decoded = raw && raw !== `0x${"00".repeat(32)}` ? hexToString(raw, { size: 32 }) : "";
+      header(`Nickname \u2014 ${addr}`);
+      kv("Nickname", decoded || "(unset)");
+      console.log();
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  user.command("votes [address]").description("List voting history. Defaults to the wallet derived from PRIVATE_KEY.").option("--page <n>", "page number", "1").option("--limit <n>", "page size (max 100)", "20").action(async (addrArg, opts) => {
+    try {
+      const addr = resolveAddress(addrArg);
+      const page = parseInt(opts.page) || 1;
+      const limit = Math.min(parseInt(opts.limit) || 20, 100);
+      const data = await apiGet(
+        `/api/users/${addr}/votes?page=${page}&limit=${limit}`
+      );
+      header(`Votes \u2014 ${addr}`);
+      kv("Total", data.total);
+      if (data.votes.length === 0) {
+        console.log("  (no votes)\n");
+        return;
+      }
+      table(
+        data.votes.map((v) => ({
+          Novel: `#${v.novel_id}`,
+          Round: v.round,
+          Revealed: v.revealed ? "yes" : "no",
+          Candidate: v.revealed ? `ID.${v.candidate_id}` : "-",
+          Claimed: v.claimed ? "yes" : "no",
+          Title: String(v.novel_title ?? "").slice(0, 28)
+        }))
+      );
+      console.log();
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  user.command("chapters [address]").description("List chapters authored by an address. Defaults to PRIVATE_KEY wallet.").option("--page <n>", "page number", "1").option("--limit <n>", "page size (max 200)", "50").action(async (addrArg, opts) => {
+    try {
+      const addr = resolveAddress(addrArg);
+      const page = parseInt(opts.page) || 1;
+      const limit = Math.min(parseInt(opts.limit) || 50, 200);
+      const data = await apiGet(`/api/users/${addr}/chapters?page=${page}&limit=${limit}`);
+      header(`Chapters \u2014 ${addr}`);
+      kv("Total", data.pagination.total);
+      if (data.chapters.length === 0) {
+        console.log("  (no chapters)\n");
+        return;
+      }
+      table(
+        data.chapters.map((c) => ({
+          Chapter: `ID.${c.id}`,
+          Novel: `#${c.novel_id}`,
+          Depth: c.depth,
+          WorldLine: c.is_world_line ? "yes" : "no",
+          Votes: c.vote_count,
+          Comments: c.comment_count,
+          Title: String(c.novel_title ?? "").slice(0, 24)
+        }))
+      );
+      console.log();
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  user.command("rewards [address]").description(
+    "Show unclaimed voting rewards, past reward claims, and participated novels. Use this to find unclaimed rewards after round settlement."
+  ).action(async (addrArg) => {
+    try {
+      const { nativeCurrency } = requireConfig();
+      const addr = resolveAddress(addrArg);
+      const data = await apiGet(`/api/users/${addr}/rewards`);
+      header(`Rewards \u2014 ${addr}`);
+      if (data.unclaimedVotes.length > 0) {
+        console.log("\n  Unclaimed voting rewards (run `vote claim <novel-id> <round>`):");
+        table(
+          data.unclaimedVotes.map((v) => ({
+            Novel: `#${v.novel_id}`,
+            Round: v.round,
+            Title: String(v.novel_title ?? "").slice(0, 32)
+          }))
+        );
+      } else {
+        console.log("\n  No unclaimed voting rewards.");
+      }
+      if (data.rewardClaims.length > 0) {
+        console.log("\n  Past reward claims:");
+        table(
+          data.rewardClaims.slice(0, 20).map((r) => ({
+            Novel: `#${r.novel_id}`,
+            Round: r.round ?? "-",
+            Source: r.source,
+            Amount: token(String(r.amount ?? "0"), nativeCurrency.decimals, nativeCurrency.symbol),
+            At: String(r.created_at ?? "").slice(0, 19)
+          }))
+        );
+      }
+      if (data.participatedNovels.length > 0) {
+        console.log(`
+  Participated in ${data.participatedNovels.length} novels.`);
+      }
+      console.log();
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/vote.ts
+init_shared();
+import { randomBytes as randomBytes2 } from "crypto";
+import chalk5 from "chalk";
+import { parseEther as parseEther6, toHex as toHex2 } from "viem";
+import { privateKeyToAccount as privateKeyToAccount5 } from "viem/accounts";
+
+// ../packages/shared/dist/chain/vote-store.js
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync5, renameSync, writeFileSync as writeFileSync3 } from "fs";
+import { homedir } from "os";
+import { join as join5 } from "path";
+import { randomBytes } from "crypto";
+var STORE_DIR = join5(homedir(), ".onchain-novel");
+var STORE_FILE = join5(STORE_DIR, "vote-salts.json");
+function load() {
+  if (!existsSync5(STORE_FILE))
+    return {};
+  try {
+    return JSON.parse(readFileSync5(STORE_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function persist(store) {
+  if (!existsSync5(STORE_DIR))
+    mkdirSync3(STORE_DIR, { recursive: true, mode: 448 });
+  const tmp = `${STORE_FILE}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+  writeFileSync3(tmp, JSON.stringify(store, null, 2) + "\n", { mode: 384 });
+  renameSync(tmp, STORE_FILE);
+}
+function makeKey(novelId, round, voter) {
+  return `${novelId}:${round}:${voter.toLowerCase()}`;
+}
+function saveVoteSalt(record) {
+  const store = load();
+  store[makeKey(BigInt(record.novelId), record.round, record.voter)] = {
+    ...record,
+    createdAt: Math.floor(Date.now() / 1e3)
+  };
+  persist(store);
+}
+function getVoteSalt(novelId, round, voter) {
+  const store = load();
+  return store[makeKey(novelId, round, voter)] ?? null;
+}
+function getStorePath() {
+  return STORE_FILE;
+}
+function listVoteSalts(novelId, voter, round) {
+  const store = load();
+  const voterLower = voter.toLowerCase();
+  const prefix = `${novelId}:`;
+  return Object.entries(store).filter(([k, v]) => {
+    if (!k.startsWith(prefix))
+      return false;
+    if (v.voter.toLowerCase() !== voterLower)
+      return false;
+    if (round !== void 0 && v.round !== round)
+      return false;
+    return true;
+  }).map(([, v]) => v).sort((a, b) => b.round - a.round || b.createdAt - a.createdAt);
+}
+
+// src/commands/vote.ts
+function parseIdList(raw) {
+  return raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0).map((s) => BigInt(s));
+}
+function generateSalt() {
+  return toHex2(randomBytes2(32));
+}
+function registerVoteCommands(program2) {
+  const vote = program2.command("vote").description("Voting commands");
+  vote.command("start <novel-id> <leaves>").description(
+    "Start a new voting round (keeper / owner only). <leaves> is a comma-separated list of leaf chapter IDs (one per current world line, deepest leaf preferred). Each must be a true tree leaf (no children)."
+  ).action(async (novelId, leavesArg) => {
+    try {
+      const client2 = getWalletClient();
+      const contracts = getContracts();
+      const hash = await startRound(client2, {
+        novelId: BigInt(novelId),
+        leaves: parseIdList(leavesArg),
+        roundManager: contracts.roundManager
+      });
+      txHash(hash);
+      await waitForTx(hash);
+      success("Round started");
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  vote.command("close-nomination <novel-id>").description("Close the nomination phase").action(async (novelId) => {
+    try {
+      const client2 = getWalletClient();
+      const contracts = getContracts();
+      const hash = await closeNomination(client2, BigInt(novelId), contracts.roundManager);
+      txHash(hash);
+      await waitForTx(hash);
+      success("Nomination closed");
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  vote.command("close-commit <novel-id>").description("Close the commit phase").action(async (novelId) => {
+    try {
+      const client2 = getWalletClient();
+      const contracts = getContracts();
+      const hash = await closeCommit(client2, BigInt(novelId), contracts.roundManager);
+      txHash(hash);
+      await waitForTx(hash);
+      success("Commit phase closed");
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  vote.command("nominate <novel-id> <chapter-id>").description(
+    "Nominate a chapter as candidate. By default the path proof (chapter \u2192 current worldLineAncestor) is auto-computed so the nominator is reward-eligible. Pass --forfeit to nominate an arbitrary chapter with no reward eligibility (empty path)."
+  ).option("--value <eth>", "nomination fee in ETH").option("--forfeit", "nominate without reward eligibility (skip path proof)").action(async (novelId, chapterId, opts) => {
+    try {
+      const client2 = getWalletClient();
+      const pub = getPublicClient();
+      const contracts = getContracts();
+      let value;
+      if (opts.value) {
+        value = parseEther6(opts.value);
+      } else {
+        const { config } = await fetchNovelConfig(novelId);
+        value = BigInt(config.nominationFee ?? "0");
+      }
+      let path = [];
+      if (!opts.forfeit) {
+        const ancestors = await pub.readContract({
+          address: contracts.novelCore,
+          abi: (await Promise.resolve().then(() => (init_shared(), shared_exports))).novelCoreAbi,
+          functionName: "getWorldLineAncestors",
+          args: [BigInt(novelId)]
+        });
+        const proof = await buildPathToAnchor(
+          pub,
+          contracts.novelCore,
+          BigInt(novelId),
+          BigInt(chapterId),
+          ancestors
+        );
+        if (!proof || proof.length < 2) {
+          error(
+            `Chapter ID.${chapterId} is not a strict descendant of any current worldLineAncestor of novel #${novelId}. Pass --forfeit to nominate anyway (no reward eligibility).`
+          );
+          return process.exit(1);
+        }
+        path = proof;
+      }
+      const hash = await nominateCandidate(client2, {
+        novelId: BigInt(novelId),
+        chapterId: BigInt(chapterId),
+        path,
+        value,
+        roundManager: contracts.roundManager
+      });
+      txHash(hash);
+      await waitForTx(hash);
+      success(opts.forfeit ? "Chapter nominated (forfeit mode)" : "Chapter nominated");
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  vote.command("commit <novel-id> <candidate-id> [salt]").description(
+    "Commit a vote. If salt is omitted, a random 32-byte salt is generated, saved locally as backup, and submitted to the backend for keeper-assisted reveal."
+  ).option("--value <eth>", "vote stake in ETH").option("--no-keeper", "skip backend submission (you must reveal manually later)").action(async (novelId, candidateId, saltArg, opts) => {
+    try {
+      const client2 = getWalletClient();
+      const contracts = getContracts();
+      const voter = client2.account.address;
+      const saltBytes32 = saltArg ? toBytes32Salt(saltArg) : generateSalt();
+      const commitHash = computeCommitHash(voter, BigInt(candidateId), saltBytes32);
+      console.log(chalk5.gray(`  Salt (bytes32): ${saltBytes32}`));
+      console.log(chalk5.gray(`  Commit hash:    ${commitHash}`));
+      const { novel, config } = await fetchNovelConfig(novelId);
+      const currentRound = Number(novel.current_round ?? 0);
+      const value = opts.value ? parseEther6(opts.value) : BigInt(config.voteStake ?? "0");
+      const hash = await commitVote(client2, {
+        novelId: BigInt(novelId),
+        commitHash,
+        value,
+        roundManager: contracts.roundManager
+      });
+      txHash(hash);
+      await waitForTx(hash);
+      if (currentRound > 0) {
+        saveVoteSalt({
+          novelId: novelId.toString(),
+          round: currentRound,
+          candidateId: candidateId.toString(),
+          salt: saltBytes32,
+          voter
+        });
+        console.log(chalk5.gray(`  Salt saved to ${getStorePath()}`));
+      }
+      if (opts.keeper !== false && currentRound > 0) {
+        const ts = Math.floor(Date.now() / 1e3);
+        const message = `Submit vote on novel ${novelId} round ${currentRound} for candidate ${candidateId} at ${ts}`;
+        const signature = await client2.signMessage({ account: client2.account, message });
+        const result = await apiPost("/api/votes/submit", {
+          address: voter,
+          novelId: Number(novelId),
+          round: currentRound,
+          candidateId: Number(candidateId),
+          salt: saltBytes32,
+          timestamp: ts,
+          signature
+        });
+        if (result.status === 201) {
+          success("Vote committed. Keeper will auto-reveal during the reveal phase.");
+        } else if (result.status === 503) {
+          success("Vote committed (keeper-assisted reveal disabled on backend).");
+          console.log(
+            chalk5.yellow(
+              "  You will need to reveal manually with: vote reveal <novel-id> <candidate-id> <salt>"
+            )
+          );
+        } else {
+          success("Vote committed.");
+          console.log(
+            chalk5.yellow(
+              `  Backend rejected /api/votes/submit (status ${result.status}). You will need to reveal manually.`
+            )
+          );
+        }
+      } else {
+        success("Vote committed. Remember to reveal during the reveal phase.");
+      }
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  vote.command("reveal <novel-id> <candidate-id> [salt]").description(
+    "Reveal a previously committed vote. If salt is omitted, falls back to the local backup saved by `vote commit`. Anyone can call revealVote on behalf of a voter \u2014 only the matching voter address whose commit hash equals keccak(voter, c, s) will succeed."
+  ).action(async (novelId, candidateId, saltArg) => {
+    try {
+      const client2 = getWalletClient();
+      const contracts = getContracts();
+      const voter = client2.account.address;
+      let saltBytes32;
+      if (saltArg) {
+        saltBytes32 = toBytes32Salt(saltArg);
+      } else {
+        const novel = await apiGet(`/api/novels/${novelId}`);
+        const currentRound = Number(novel.current_round ?? 0);
+        const stored = getVoteSalt(BigInt(novelId), currentRound, voter);
+        if (!stored) {
+          error(`No salt provided and no local backup found for round ${currentRound}.`);
+          process.exit(1);
+        }
+        saltBytes32 = stored.salt;
+        console.log(chalk5.gray(`  Using salt from local backup (round ${currentRound})`));
+      }
+      const hash = await revealVote(client2, {
+        novelId: BigInt(novelId),
+        voter,
+        candidateId: BigInt(candidateId),
+        salt: saltBytes32,
+        roundManager: contracts.roundManager
+      });
+      txHash(hash);
+      await waitForTx(hash);
+      success("Vote revealed");
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  vote.command("settle <novel-id>").description(
+    "Settle the current round (keeper / owner, or anyone after the timeout). Winner reward-author derivation happens fully on-chain via NovelCore.collectPathAuthors."
+  ).action(async (novelId) => {
+    try {
+      const client2 = getWalletClient();
+      const contracts = getContracts();
+      const hash = await settleRound(client2, {
+        novelId: BigInt(novelId),
+        roundManager: contracts.roundManager
+      });
+      txHash(hash);
+      await waitForTx(hash);
+      success("Round settled");
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  vote.command("claim <novel-id> <round>").description("Claim voting reward for a specific round").action(async (novelId, round) => {
+    try {
+      const client2 = getWalletClient();
+      const contracts = getContracts();
+      const hash = await claimVotingReward(
+        client2,
+        BigInt(novelId),
+        parseInt(round),
+        contracts.roundManager
+      );
+      txHash(hash);
+      await waitForTx(hash);
+      success("Voting reward claimed");
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  vote.command("candidates <novel-id>").description("Show current round candidates").action(async (novelId) => {
+    try {
+      const novel = await apiGet(`/api/novels/${novelId}`);
+      const currentRound = Number(novel.current_round);
+      const phase = Number(novel.round_phase);
+      header(`Voting \u2014 Novel #${novelId}`);
+      kv("Current Round", currentRound);
+      kv("Phase", roundPhaseName(phase));
+      if (currentRound === 0) {
+        console.log(chalk5.yellow("\n  No voting round has started yet.\n"));
+        return;
+      }
+      const roundData = await apiGet(
+        `/api/novels/${novelId}/rounds/${currentRound}`
+      );
+      const wlData = await apiGet(
+        `/api/novels/${novelId}/worldlines`
+      );
+      if (wlData.worldlines.length > 0) {
+        console.log(chalk5.bold("\n  World Lines:"));
+        for (const wl of wlData.worldlines) {
+          console.log(
+            `    Chapter ID.${wl.id} (depth=${wl.depth}) by ${String(wl.author ?? "").slice(0, 10)}...`
+          );
+        }
+      }
+      if (roundData.votes.length > 0) {
+        console.log(chalk5.bold("\n  Votes:"));
+        table(
+          roundData.votes.map((v) => ({
+            Voter: String(v.voter ?? "").slice(0, 12) + "...",
+            Revealed: v.revealed ? "Yes" : "No",
+            Candidate: v.revealed ? `ID.${v.candidate_id}` : "-",
+            Claimed: v.claimed ? "Yes" : "No"
+          }))
+        );
+      }
+      console.log();
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  vote.command("discover").description(
+    "List active novels with a round in progress \u2014 the starting point for an agent looking for voting opportunities. Shows phase, deadline, and whether you already voted."
+  ).option("--phase <phase>", "filter by phase: nominating|committing|revealing|all", "all").option("--limit <n>", "max novels to scan", "100").action(async (opts) => {
+    try {
+      const { nativeCurrency } = requireConfig();
+      const wantPhase = String(opts.phase).toLowerCase();
+      const phaseMap = {
+        nominating: 1,
+        committing: 2,
+        revealing: 3
+      };
+      const phaseFilter = wantPhase === "all" ? null : phaseMap[wantPhase];
+      if (wantPhase !== "all" && phaseFilter === void 0) {
+        error(`Invalid --phase. Use one of: nominating, committing, revealing, all`);
+        process.exit(1);
+      }
+      const limit = Math.min(parseInt(String(opts.limit)) || 100, 100);
+      const data = await apiGet(
+        `/api/novels?filter=active&limit=${limit}&sort=active`
+      );
+      const now = Math.floor(Date.now() / 1e3);
+      const pk = getPrivateKey2();
+      const myAddr = pk ? privateKeyToAccount5(pk).address.toLowerCase() : null;
+      const rows = [];
+      for (const n of data.novels) {
+        const phase = Number(n.round_phase);
+        if (phase === 0) continue;
+        if (phaseFilter !== null && phase !== phaseFilter) continue;
+        const cfg = n.config ?? {};
+        const phaseStart = Number(n.phase_start_time ?? 0);
+        const durKey = phase === 1 ? "nominateDuration" : phase === 2 ? "commitDuration" : "revealDuration";
+        const duration = Number(cfg[durKey] ?? 0);
+        const deadline = phaseStart + duration;
+        const remaining = deadline - now;
+        let already = "-";
+        let voterCount = 0;
+        if (phase >= 2) {
+          try {
+            const round = Number(n.current_round);
+            if (round > 0) {
+              const rd = await apiGet(
+                `/api/novels/${n.id}/rounds/${round}`
+              );
+              voterCount = rd.votes.length;
+              if (myAddr) {
+                const mine = rd.votes.find(
+                  (v) => String(v.voter ?? "").toLowerCase() === myAddr
+                );
+                already = mine ? mine.revealed ? "revealed" : "committed" : "no";
+              }
+            }
+          } catch {
+          }
+        }
+        rows.push({
+          Novel: `#${n.id}`,
+          Title: String(n.title ?? "").slice(0, 28),
+          Round: n.current_round,
+          Phase: roundPhaseName(phase),
+          Deadline: remaining > 0 ? `${Math.floor(remaining / 3600)}h${Math.floor(remaining % 3600 / 60)}m` : chalk5.red("expired"),
+          Pool: token(BigInt(String(n.pool_balance ?? "0")), nativeCurrency.decimals, nativeCurrency.symbol),
+          Voters: voterCount,
+          VoteStake: cfg.voteStake ? token(cfg.voteStake, nativeCurrency.decimals, nativeCurrency.symbol) : "-",
+          Voted: already
+        });
+      }
+      header("Voting Opportunities");
+      if (rows.length === 0) {
+        console.log(chalk5.gray("  No novels currently in a voting phase.\n"));
+        return;
+      }
+      table(rows);
+      console.log();
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+  vote.command("status <novel-id>").description(
+    "Show your voting status for a novel: current phase, deadline, locally-stored salts, and on-chain reveal status. Use this to avoid missing the reveal window."
+  ).action(async (novelId) => {
+    try {
+      const novel = await apiGet(`/api/novels/${novelId}`);
+      const round = Number(novel.current_round ?? 0);
+      const phase = Number(novel.round_phase ?? 0);
+      const cfg = novel.config ?? {};
+      const phaseStart = Number(novel.phase_start_time ?? 0);
+      const now = Math.floor(Date.now() / 1e3);
+      header(`Vote Status \u2014 Novel #${novelId}`);
+      kv("Round", round);
+      kv("Phase", roundPhaseName(phase));
+      if (phase !== 0) {
+        const durKey = phase === 1 ? "nominateDuration" : phase === 2 ? "commitDuration" : "revealDuration";
+        const duration = Number(cfg[durKey] ?? 0);
+        const deadline = phaseStart + duration;
+        const remaining = deadline - now;
+        kv(
+          "Deadline",
+          remaining > 0 ? `in ${Math.floor(remaining / 3600)}h ${Math.floor(remaining % 3600 / 60)}m` : chalk5.red("expired")
+        );
+      }
+      const pk = getPrivateKey2();
+      if (!pk) {
+        console.log(chalk5.gray("\n  (PRIVATE_KEY not set \u2014 skipping per-voter details)\n"));
+        return;
+      }
+      const voter = privateKeyToAccount5(pk).address;
+      kv("Voter", voter);
+      if (round > 0) {
+        try {
+          const rd = await apiGet(
+            `/api/novels/${novelId}/rounds/${round}`
+          );
+          const mine = rd.votes.filter(
+            (v) => String(v.voter ?? "").toLowerCase() === voter.toLowerCase()
+          );
+          if (mine.length > 0) {
+            console.log(chalk5.bold("\n  On-chain votes this round:"));
+            table(
+              mine.map((v) => ({
+                Committed: v.commit_hash ? "yes" : "no",
+                Revealed: v.revealed ? "yes" : "no",
+                Candidate: v.revealed ? `ID.${v.candidate_id}` : "-",
+                Claimed: v.claimed ? "yes" : "no"
+              }))
+            );
+          }
+        } catch {
+        }
+      }
+      const salts = listVoteSalts(BigInt(novelId), voter);
+      if (salts.length > 0) {
+        console.log(chalk5.bold("\n  Local salt backups:"));
+        table(
+          salts.slice(0, 10).map((s) => ({
+            Round: s.round,
+            Candidate: `ID.${s.candidateId}`,
+            SavedAt: new Date(s.createdAt * 1e3).toISOString().slice(0, 19).replace("T", " ")
+          }))
+        );
+        kv("Store", getStorePath());
+      } else {
+        console.log(chalk5.gray("\n  No local salt backups for this novel."));
+      }
+      console.log();
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/bin/onchain-novel-cli.ts
+program.name("onchain-novel-cli").description(
+  "Onchain Novel Protocol CLI \u2014 create, write, vote, tip, and manage collaborative on-chain novels"
+).version("0.1.0");
+var NO_BOOTSTRAP = /* @__PURE__ */ new Set(["setup", "guide", "config"]);
+program.hook("preAction", async (_thisCmd, actionCmd) => {
+  const top = actionCmd.parent?.name() === "onchain-novel-cli" ? actionCmd.name() : actionCmd.parent?.name();
+  if (top && NO_BOOTSTRAP.has(top)) return;
+  await ensureBootstrapped();
+});
+registerSetupCommand(program);
+registerAdminCommands(program);
+registerConfigCommand(program);
+registerNovelCommands(program);
+registerChapterCommands(program);
+registerVoteCommands(program);
+registerTipCommands(program);
+registerBountyCommands(program);
+registerRuleCommands(program);
+registerUserCommands(program);
+registerFaucetCommands(program);
+registerGuideCommands(program);
+program.parseAsync().catch((err) => {
+  console.error(String(err));
+  process.exit(1);
+});