@txtcel/mcp 0.1.2 → 0.2.0

package/dist/index.js

@@ -47867,7 +47867,6 @@ function loadWallet() {
 var import_zorsh = __toESM(require_src2(), 1);
 import { Buffer as Buffer3 } from "buffer";
 var TAG_CONTENT = 1;
-var TAG_ALLOC = 2;
 var TAG_THREAD = 3;
 var TAG_SETTINGS = 5;
 var TAG_ACCESS = 6;
@@ -47875,12 +47874,11 @@ var TAG_LIKES = 7;
 var TAG_ACCESS_ENTRY = 9;
 var TAG_FOLLOW_REGISTRY = 10;
 var TAG_FOLLOWER_SHARD = 11;
-var KIND_TEXT = 0;
 var ACCESS_ALLOWED = 0;
 var ACCESS_DENIED = 1;
 var ACCESS_FEE_EXEMPT = 2;
-var NEXT_ALLOC_INDEX = 31;
-var CONTENT_SLOTS = 31;
+var KIND_TEXT = 0;
+var CONTENT_SLOTS = 32;
 var EXTEND_THRESHOLD = 16;
 var MAX_BODY_LEN = 8192;
 var MAX_TITLE_LEN = 64;
@@ -47954,9 +47952,7 @@ var ContentNodeSchema = import_zorsh.b.struct({
 var AllocNodeSchema = import_zorsh.b.struct({
   tag: import_zorsh.b.u8(),
   thread: Pubkey,
-  allocSeq: import_zorsh.b.u32(),
-  upperAllocSeq: import_zorsh.b.u32(),
-  nextAllocSeq: import_zorsh.b.u32()
+  allocSeq: import_zorsh.b.u32()
 });
 var ThreadNodeSchema = import_zorsh.b.struct({
   tag: import_zorsh.b.u8(),
@@ -47993,7 +47989,7 @@ var AccessEntrySchema = import_zorsh.b.struct({
 var AllocLikesSchema = import_zorsh.b.struct({
   tag: import_zorsh.b.u8(),
   allocSeq: import_zorsh.b.u32(),
-  counts: import_zorsh.b.array(import_zorsh.b.u32(), NEXT_ALLOC_INDEX)
+  counts: import_zorsh.b.array(import_zorsh.b.u32(), CONTENT_SLOTS)
 });
 var FollowRegistrySchema = import_zorsh.b.struct({
   tag: import_zorsh.b.u8(),
@@ -48029,7 +48025,6 @@ var FillSlotInstr = import_zorsh.b.struct({
   kind: import_zorsh.b.u16(),
   body: import_zorsh.b.bytes(),
   candidates: import_zorsh.b.vec(CandidateSlotSchema),
-  extend: import_zorsh.b.u8(),
   treasuryShardIdx: import_zorsh.b.u16(),
   authorFeeShardIdx: import_zorsh.b.u8(),
   replyAllocSeq: import_zorsh.b.u32(),
@@ -48083,17 +48078,6 @@ function decodeContent(pubkey, data) {
     text: raw.kind === KIND_TEXT ? textDecoder.decode(raw.body) : ""
   };
 }
-function decodeAlloc(pubkey, data) {
-  const raw = AllocNodeSchema.deserialize(data);
-  if (raw.tag !== TAG_ALLOC) throw new Error("Invalid AllocNode tag");
-  return {
-    pubkey,
-    seed: raw.thread,
-    allocSeq: raw.allocSeq,
-    upperAllocSeq: raw.upperAllocSeq === INDEX_NONE ? null : raw.upperAllocSeq,
-    nextAllocSeq: raw.nextAllocSeq === INDEX_NONE ? null : raw.nextAllocSeq
-  };
-}
 var textDecoder2 = new TextDecoder();
 function decodeThread(pubkey, data) {
   const raw = ThreadNodeSchema.deserialize(data);
@@ -48250,47 +48234,46 @@ function randomTreasuryShard() {
 function randomAuthorFeeShard() {
   return Math.floor(Math.random() * N_AUTHOR_FEE_SHARDS);
 }
+function assertOwnedTag(info, programId, tag, name) {
+  if (!info.owner.equals(programId)) throw new Error(`${name} not owned by program`);
+  if (info.data.length === 0 || info.data[0] !== tag) throw new Error(`Invalid ${name} data`);
+}
+async function fetchRequiredAccount(connection, programId, key, tag, name) {
+  const info = await connection.getAccountInfo(key, "confirmed");
+  if (!info) throw new Error(`${name} not found`);
+  assertOwnedTag(info, programId, tag, name);
+  return info;
+}
+async function fetchOptionalAccount(connection, programId, key, tag, name) {
+  const info = await connection.getAccountInfo(key, "confirmed");
+  if (!info) return null;
+  assertOwnedTag(info, programId, tag, name);
+  return info;
+}
+function isOwnedTag(info, programId, tag) {
+  return info !== null && info.owner.equals(programId) && info.data.length > 0 && info.data[0] === tag;
+}
 async function loadThreadNode(connection, programId, pubkey) {
-  const info = await connection.getAccountInfo(pubkey, "confirmed");
-  if (!info) throw new Error("ThreadNode not found");
-  if (!info.owner.equals(programId)) throw new Error("ThreadNode not owned by program");
-  if (info.data.length === 0 || info.data[0] !== TAG_THREAD) throw new Error("Invalid ThreadNode data");
+  const info = await fetchRequiredAccount(connection, programId, pubkey, TAG_THREAD, "ThreadNode");
   return decodeThread(pubkey.toBase58(), info.data);
 }
-async function loadAllocNode(connection, programId, pubkey) {
-  const info = await connection.getAccountInfo(pubkey, "confirmed");
-  if (!info) throw new Error("AllocNode not found");
-  if (!info.owner.equals(programId)) throw new Error("AllocNode not owned by program");
-  if (info.data.length === 0 || info.data[0] !== TAG_ALLOC) throw new Error("Invalid AllocNode data");
-  return decodeAlloc(pubkey.toBase58(), info.data);
-}
 async function loadContentNode(connection, programId, pubkey) {
-  const info = await connection.getAccountInfo(pubkey, "confirmed");
-  if (!info) throw new Error("ContentNode not found");
-  if (!info.owner.equals(programId)) throw new Error("ContentNode not owned by program");
-  if (info.data.length === 0 || info.data[0] !== TAG_CONTENT) throw new Error("Invalid ContentNode data");
+  const info = await fetchRequiredAccount(connection, programId, pubkey, TAG_CONTENT, "ContentNode");
   return decodeContent(pubkey.toBase58(), info.data);
 }
 async function loadProgramSettings(connection, programId) {
   const settingsKey = deriveSettingsPda(programId);
-  const info = await connection.getAccountInfo(settingsKey, "confirmed");
+  const info = await fetchOptionalAccount(connection, programId, settingsKey, TAG_SETTINGS, "ProgramSettings");
   if (!info) return null;
-  if (!info.owner.equals(programId)) throw new Error("ProgramSettings not owned by program");
-  if (info.data.length === 0 || info.data[0] !== TAG_SETTINGS) throw new Error("Invalid ProgramSettings data");
   return decodeSettings(settingsKey.toBase58(), info.data);
 }
 async function loadThreadAccess(connection, programId, accessKey) {
-  const info = await connection.getAccountInfo(accessKey, "confirmed");
-  if (!info) throw new Error("ThreadAccess not found");
-  if (!info.owner.equals(programId)) throw new Error("ThreadAccess not owned by program");
-  if (info.data.length === 0 || info.data[0] !== TAG_ACCESS) throw new Error("Invalid ThreadAccess data");
+  const info = await fetchRequiredAccount(connection, programId, accessKey, TAG_ACCESS, "ThreadAccess");
   return decodeThreadAccess(accessKey.toBase58(), info.data);
 }
 async function loadAllocLikes(connection, programId, pubkey) {
-  const info = await connection.getAccountInfo(pubkey, "confirmed");
+  const info = await fetchOptionalAccount(connection, programId, pubkey, TAG_LIKES, "AllocLikes");
   if (!info) return null;
-  if (!info.owner.equals(programId)) throw new Error("AllocLikes not owned by program");
-  if (info.data.length === 0 || info.data[0] !== TAG_LIKES) throw new Error("Invalid AllocLikes data");
   return decodeAllocLikes(pubkey.toBase58(), info.data);
 }
 async function loadAccessEntries(connection, programId, seed) {
@@ -48315,10 +48298,8 @@ async function loadAccessEntries(connection, programId, seed) {
 }
 async function loadFollowRegistry(connection, programId, owner) {
   const registryKey = deriveFollowRegistryPda(programId, owner);
-  const info = await connection.getAccountInfo(registryKey, "confirmed");
+  const info = await fetchOptionalAccount(connection, programId, registryKey, TAG_FOLLOW_REGISTRY, "FollowRegistry");
   if (!info) return null;
-  if (!info.owner.equals(programId)) throw new Error("FollowRegistry not owned by program");
-  if (info.data.length === 0 || info.data[0] !== TAG_FOLLOW_REGISTRY) throw new Error("Invalid FollowRegistry data");
   return decodeFollowRegistry(registryKey.toBase58(), info.data);
 }
 async function loadFollowerCount(connection, programId, seed) {
@@ -48330,8 +48311,7 @@ async function loadFollowerCount(connection, programId, seed) {
   let total = 0n;
   for (let i = 0; i < infos.length; i++) {
     const info = infos[i];
-    if (!info || !info.owner.equals(programId)) continue;
-    if (info.data.length === 0 || info.data[0] !== TAG_FOLLOWER_SHARD) continue;
+    if (!isOwnedTag(info, programId, TAG_FOLLOWER_SHARD)) continue;
     total += decodeFollowerShard(shardKeys[i].toBase58(), info.data).count;
   }
   return total;
@@ -48344,41 +48324,21 @@ async function loadThreadNodesBatched(connection, programId, channels) {
     const infos = await connection.getMultipleAccountsInfo(chunk, "confirmed");
     for (let j = 0; j < infos.length; j++) {
       const info = infos[j];
-      if (!info || !info.owner.equals(programId)) continue;
-      if (info.data.length === 0 || info.data[0] !== TAG_THREAD) continue;
+      if (!isOwnedTag(info, programId, TAG_THREAD)) continue;
       const key = chunk[j].toBase58();
       result.set(key, decodeThread(key, info.data));
     }
   }
   return result;
 }
-function buildCreateRootAllocInstruction(programId, payer, seed, messageFee = 0n, title = "") {
-  const titleBytes = new TextEncoder().encode(title);
-  if (titleBytes.length > MAX_TITLE_LEN) {
-    throw new Error(`Title is too long (max ${MAX_TITLE_LEN} bytes)`);
-  }
-  const threadAccount = deriveThreadPda(programId, seed);
-  const allocAccount = deriveAllocPda(programId, seed, 0);
-  const settingsAccount = deriveSettingsPda(programId);
-  const treasuryShardIdx = randomTreasuryShard();
-  const treasuryShard = deriveTreasuryShardPda(programId, treasuryShardIdx);
-  return new TransactionInstruction({
-    programId,
-    keys: [
-      { pubkey: payer, isSigner: true, isWritable: true },
-      { pubkey: threadAccount, isSigner: true, isWritable: true },
-      { pubkey: allocAccount, isSigner: false, isWritable: true },
-      { pubkey: settingsAccount, isSigner: false, isWritable: false },
-      { pubkey: treasuryShard, isSigner: false, isWritable: true },
-      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false }
-    ],
-    data: Buffer3.from(CreateRootAllocInstr.serialize({
-      tag: Instruction.CreateRootAlloc,
-      messageFee,
-      treasuryShardIdx,
-      title: titleBytes
-    }))
-  });
+function signerMeta(pubkey) {
+  return { pubkey, isSigner: true, isWritable: true };
+}
+function writableMeta(pubkey) {
+  return { pubkey, isSigner: false, isWritable: true };
+}
+function readonlyMeta(pubkey) {
+  return { pubkey, isSigner: false, isWritable: false };
 }
 function buildFillSlotInstruction(opts) {
   const {
@@ -48391,7 +48351,6 @@ function buildFillSlotInstruction(opts) {
     bodyBytes,
     kind = KIND_TEXT,
     maxFee,
-    extendInfo,
     replyAllocSeq: replyAllocSeqRaw,
     replySlot: replySlotRaw
   } = opts;
@@ -48402,22 +48361,18 @@ function buildFillSlotInstruction(opts) {
   const accessAccount = deriveAccessPda(programId, seed);
   const entryAccount = deriveAccessEntryPda(programId, seed, payer);
   const keys = [
-    { pubkey: payer, isSigner: true, isWritable: true },
-    { pubkey: threadAccount, isSigner: false, isWritable: !!extendInfo },
-    { pubkey: settingsAccount, isSigner: false, isWritable: false },
-    { pubkey: treasuryShard, isSigner: false, isWritable: true },
-    { pubkey: authorFeeShard, isSigner: false, isWritable: true },
-    { pubkey: SystemProgram.programId, isSigner: false, isWritable: false }
+    signerMeta(payer),
+    readonlyMeta(threadAccount),
+    readonlyMeta(settingsAccount),
+    writableMeta(treasuryShard),
+    writableMeta(authorFeeShard),
+    readonlyMeta(SystemProgram.programId)
   ];
-  for (const c of candidates) {
-    keys.push({ pubkey: c.pda, isSigner: false, isWritable: true });
-  }
-  keys.push({ pubkey: accessAccount, isSigner: false, isWritable: false });
-  keys.push({ pubkey: entryAccount, isSigner: false, isWritable: false });
-  if (extendInfo) {
-    keys.push({ pubkey: extendInfo.currentAllocPda, isSigner: false, isWritable: true });
-    keys.push({ pubkey: extendInfo.newAllocPda, isSigner: false, isWritable: true });
+  for (const candidate of candidates) {
+    keys.push(writableMeta(candidate.pda));
   }
+  keys.push(readonlyMeta(accessAccount));
+  keys.push(readonlyMeta(entryAccount));
   return new TransactionInstruction({
     programId,
     keys,
@@ -48425,8 +48380,7 @@ function buildFillSlotInstruction(opts) {
       tag: Instruction.FillSlot,
       kind,
       body: bodyBytes,
-      candidates: candidates.map((c) => ({ allocSeq: c.allocSeq, slot: c.slot })),
-      extend: extendInfo ? 1 : 0,
+      candidates: candidates.map((candidate) => ({ allocSeq: candidate.allocSeq, slot: candidate.slot })),
       treasuryShardIdx,
       authorFeeShardIdx,
       replyAllocSeq: replyAllocSeqRaw ?? INDEX_NONE,
@@ -48435,17 +48389,36 @@ function buildFillSlotInstruction(opts) {
     }))
   });
 }
+function buildPrepareAllocInstruction(programId, payer, seed, allocSeq) {
+  const currentAllocPda = deriveAllocPda(programId, seed, allocSeq);
+  const newAllocPda = deriveAllocPda(programId, seed, allocSeq + 1);
+  const threadAccount = deriveThreadPda(programId, seed);
+  return new TransactionInstruction({
+    programId,
+    keys: [
+      signerMeta(payer),
+      writableMeta(currentAllocPda),
+      writableMeta(newAllocPda),
+      writableMeta(threadAccount),
+      readonlyMeta(SystemProgram.programId)
+    ],
+    data: Buffer3.from(PrepareAllocInstr.serialize({
+      tag: Instruction.PrepareAlloc,
+      allocSeq
+    }))
+  });
+}
 function buildAppendContentInstruction(programId, payer, contentAccount, threadAccount, settingsAccount, treasuryShard, authorFeeShard, chunk, treasuryShardIdx, authorFeeShardIdx) {
   return new TransactionInstruction({
     programId,
     keys: [
-      { pubkey: payer, isSigner: true, isWritable: true },
-      { pubkey: contentAccount, isSigner: false, isWritable: true },
-      { pubkey: threadAccount, isSigner: false, isWritable: false },
-      { pubkey: settingsAccount, isSigner: false, isWritable: false },
-      { pubkey: treasuryShard, isSigner: false, isWritable: true },
-      { pubkey: authorFeeShard, isSigner: false, isWritable: true },
-      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false }
+      signerMeta(payer),
+      writableMeta(contentAccount),
+      readonlyMeta(threadAccount),
+      readonlyMeta(settingsAccount),
+      writableMeta(treasuryShard),
+      writableMeta(authorFeeShard),
+      readonlyMeta(SystemProgram.programId)
     ],
     data: Buffer3.from(AppendContentInstr.serialize({
       tag: Instruction.AppendContent,
@@ -48455,6 +48428,18 @@ function buildAppendContentInstruction(programId, payer, contentAccount, threadA
     }))
   });
 }
+var TX_SIZE_LIMIT = 1232;
+var TX_OVERHEAD = 1 + 64 + 3 + 32;
+var FILL_SLOT_FIXED_OVERHEAD = 1 + 2 + 4 + 4 + 2 + 1 + 4 + 1 + 8;
+var CANDIDATE_SIZE = 4 + 1;
+var ACCOUNT_KEY_SIZE = 32;
+var FILL_SLOT_BASE_ACCOUNTS = 6;
+var FILL_SLOT_ACCESS_ACCOUNTS = 2;
+var PREPARE_ALLOC_MARGINAL_SIZE = 2 * ACCOUNT_KEY_SIZE + 1 + 1 + 5 + 1 + (1 + 4);
+var CONTENT_NODE_FIXED_SIZE = 89;
+var MAX_FEE_SLIPPAGE_NUM = 2n;
+var APPEND_INSTR_ACCOUNTS = 7;
+var APPEND_TX_OVERHEAD = TX_OVERHEAD + 1 + (APPEND_INSTR_ACCOUNTS + 1) * ACCOUNT_KEY_SIZE + 1 + 1 + 1 + APPEND_INSTR_ACCOUNTS + 2 + 1 + 4 + 2 + 1;
 function ensureTextBytes(text) {
   const bytes = new TextEncoder().encode(text);
   if (bytes.length === 0) {
@@ -48473,74 +48458,41 @@ function shuffle(arr) {
   }
   return result;
 }
-var TX_SIZE_LIMIT = 1232;
-var TX_OVERHEAD = 1 + 64 + 3 + 32;
-var FILL_SLOT_FIXED_OVERHEAD = 1 + 2 + 4 + 4 + 1 + 2 + 1 + 4 + 1 + 8;
-var CANDIDATE_SIZE = 4 + 1;
-var ACCOUNT_KEY_SIZE = 32;
-var FILL_SLOT_BASE_ACCOUNTS = 6;
-var FILL_SLOT_ACCESS_ACCOUNTS = 2;
-var CONTENT_NODE_FIXED_SIZE = 89;
-var MAX_FEE_SLIPPAGE_NUM = 2n;
-var APPEND_INSTR_ACCOUNTS = 7;
-var APPEND_TX_OVERHEAD = TX_OVERHEAD + 1 + (APPEND_INSTR_ACCOUNTS + 1) * ACCOUNT_KEY_SIZE + 1 + 1 + 1 + APPEND_INSTR_ACCOUNTS + 2 + 1 + 4 + 2 + 1;
-function estimateFillSlotTxSize(nCandidates, hasExtend, textLen) {
-  const nAccounts = FILL_SLOT_BASE_ACCOUNTS + nCandidates + FILL_SLOT_ACCESS_ACCOUNTS + (hasExtend ? 2 : 0);
+function estimateFillSlotTxSize(nCandidates, textLen) {
+  const nAccounts = FILL_SLOT_BASE_ACCOUNTS + nCandidates + FILL_SLOT_ACCESS_ACCOUNTS;
   const accountsSize = 1 + (nAccounts + 1) * ACCOUNT_KEY_SIZE;
   const instrDataSize = FILL_SLOT_FIXED_OVERHEAD + textLen + nCandidates * CANDIDATE_SIZE;
   const instrOverhead = 1 + 1 + 1 + nAccounts + 2;
   return TX_OVERHEAD + accountsSize + instrOverhead + instrDataSize;
 }
-function maxFillSlotTextLen(nCandidates, hasExtend) {
-  const withoutText = estimateFillSlotTxSize(nCandidates, hasExtend, 0);
-  return TX_SIZE_LIMIT - withoutText;
+function maxFillSlotTextLen(nCandidates, reserve = 0) {
+  const withoutText = estimateFillSlotTxSize(nCandidates, 0);
+  return TX_SIZE_LIMIT - withoutText - reserve;
 }
 function maxAppendChunkLen() {
   return TX_SIZE_LIMIT - APPEND_TX_OVERHEAD;
 }
+function pageCandidates(programId, seed, allocSeq) {
+  return Array.from({ length: CONTENT_SLOTS }, (_, slot) => ({
+    pda: deriveContentPda(programId, seed, allocSeq, slot),
+    allocSeq,
+    slot
+  }));
+}
 async function buildSendMessageTransactions(connection, programId, payerKey, seed, text, replyTo) {
   const textBytes = ensureTextBytes(text);
   const threadPda = deriveThreadPda(programId, seed);
   const thread = await loadThreadNode(connection, programId, threadPda);
   const lastAllocSeq = thread.lastAllocSeq;
-  const lastAllocPda = deriveAllocPda(programId, seed, lastAllocSeq);
-  const lastAlloc = await loadAllocNode(connection, programId, lastAllocPda);
-  const lastAllocCandidates = Array.from({ length: CONTENT_SLOTS }, (_, slot) => ({
-    pda: deriveContentPda(programId, seed, lastAllocSeq, slot),
-    allocSeq: lastAllocSeq,
-    slot
-  }));
-  const lastInfos = await connection.getMultipleAccountsInfo(
-    lastAllocCandidates.map((c) => c.pda)
-  );
-  const freeInLast = lastAllocCandidates.filter((_, i) => lastInfos[i] === null);
-  let freeInNext = [];
-  if (freeInLast.length < DESIRED_CANDIDATES && lastAlloc.nextAllocSeq !== null) {
-    const nextSeq = lastAlloc.nextAllocSeq;
-    const nextAllocCandidates = Array.from({ length: CONTENT_SLOTS }, (_, slot) => ({
-      pda: deriveContentPda(programId, seed, nextSeq, slot),
-      allocSeq: nextSeq,
-      slot
-    }));
-    const nextInfos = await connection.getMultipleAccountsInfo(
-      nextAllocCandidates.map((c) => c.pda)
-    );
-    freeInNext = nextAllocCandidates.filter((_, i) => nextInfos[i] === null);
-  }
-  const allFree = [...freeInLast, ...freeInNext];
-  if (allFree.length === 0) throw new Error("No free slots in thread");
-  const selected = shuffle(allFree).slice(0, DESIRED_CANDIDATES);
+  const windowCandidates = lastAllocSeq >= 1 ? [...pageCandidates(programId, seed, lastAllocSeq - 1), ...pageCandidates(programId, seed, lastAllocSeq)] : pageCandidates(programId, seed, lastAllocSeq);
+  const windowInfos = await connection.getMultipleAccountsInfo(windowCandidates.map((c) => c.pda));
+  const freeInWindow = windowCandidates.filter((_, i) => windowInfos[i] === null);
   const treasuryShardIdx = randomTreasuryShard();
   const authorFeeShardIdx = randomAuthorFeeShard();
-  const filledInLast = CONTENT_SLOTS - freeInLast.length;
-  let extendInfo;
-  if (filledInLast >= EXTEND_THRESHOLD && lastAlloc.nextAllocSeq === null) {
-    extendInfo = {
-      currentAllocPda: lastAllocPda,
-      newAllocPda: deriveAllocPda(programId, seed, lastAllocSeq + 1)
-    };
-  }
-  const maxFirst = maxFillSlotTextLen(selected.length, !!extendInfo);
+  const extendInline = freeInWindow.length === 0;
+  const selected = extendInline ? pageCandidates(programId, seed, lastAllocSeq + 1).slice(0, DESIRED_CANDIDATES) : shuffle(freeInWindow).slice(0, DESIRED_CANDIDATES);
+  const reserve = extendInline ? PREPARE_ALLOC_MARGINAL_SIZE : 0;
+  const maxFirst = maxFillSlotTextLen(selected.length, reserve);
   const firstChunkLen = Math.min(textBytes.length, maxFirst);
   const firstChunk = textBytes.subarray(0, firstChunkLen);
   const settings = await loadProgramSettings(connection, programId);
@@ -48560,16 +48512,19 @@ async function buildSendMessageTransactions(connection, programId, payerKey, see
     authorFeeShardIdx,
     bodyBytes: firstChunk,
     maxFee,
-    extendInfo,
     replyAllocSeq: replyTo?.allocSeq ?? null,
     replySlot: replyTo?.slot ?? null
   });
-  const transactions = [new Transaction().add(fillSlotIx)];
+  const firstTx = new Transaction();
+  if (extendInline) {
+    firstTx.add(buildPrepareAllocInstruction(programId, payerKey, seed, lastAllocSeq));
+  }
+  firstTx.add(fillSlotIx);
+  const transactions = [firstTx];
   if (firstChunkLen < textBytes.length) {
     const remaining = textBytes.subarray(firstChunkLen);
     const appendMax = maxAppendChunkLen();
     const contentPda = selected[0].pda;
-    const threadPda2 = deriveThreadPda(programId, seed);
     const settingsPda = deriveSettingsPda(programId);
     const treasuryShardPda = deriveTreasuryShardPda(programId, treasuryShardIdx);
     const authorFeeShardPda = deriveAuthorFeePda(programId, seed, authorFeeShardIdx);
@@ -48579,7 +48534,7 @@ async function buildSendMessageTransactions(connection, programId, payerKey, see
         programId,
         payerKey,
         contentPda,
-        threadPda2,
+        threadPda,
         settingsPda,
         treasuryShardPda,
         authorFeeShardPda,
@@ -48592,6 +48547,45 @@ async function buildSendMessageTransactions(connection, programId, payerKey, see
   }
   return transactions;
 }
+async function buildExtendAllocTransaction(connection, programId, payerKey, seed) {
+  const threadPda = deriveThreadPda(programId, seed);
+  const thread = await loadThreadNode(connection, programId, threadPda);
+  const lastAllocSeq = thread.lastAllocSeq;
+  const tailCandidates = pageCandidates(programId, seed, lastAllocSeq);
+  const tailInfos = await connection.getMultipleAccountsInfo(tailCandidates.map((c) => c.pda));
+  const freeOnPageN = tailInfos.filter((info) => info === null).length;
+  const filled = CONTENT_SLOTS - freeOnPageN;
+  if (filled < EXTEND_THRESHOLD) return null;
+  return new Transaction().add(buildPrepareAllocInstruction(programId, payerKey, seed, lastAllocSeq));
+}
+function buildCreateRootAllocInstruction(programId, payer, seed, messageFee = 0n, title = "") {
+  const titleBytes = new TextEncoder().encode(title);
+  if (titleBytes.length > MAX_TITLE_LEN) {
+    throw new Error(`Title is too long (max ${MAX_TITLE_LEN} bytes)`);
+  }
+  const threadAccount = deriveThreadPda(programId, seed);
+  const allocAccount = deriveAllocPda(programId, seed, 0);
+  const settingsAccount = deriveSettingsPda(programId);
+  const treasuryShardIdx = randomTreasuryShard();
+  const treasuryShard = deriveTreasuryShardPda(programId, treasuryShardIdx);
+  return new TransactionInstruction({
+    programId,
+    keys: [
+      signerMeta(payer),
+      signerMeta(threadAccount),
+      writableMeta(allocAccount),
+      readonlyMeta(settingsAccount),
+      writableMeta(treasuryShard),
+      readonlyMeta(SystemProgram.programId)
+    ],
+    data: Buffer3.from(CreateRootAllocInstr.serialize({
+      tag: Instruction.CreateRootAlloc,
+      messageFee,
+      treasuryShardIdx,
+      title: titleBytes
+    }))
+  });
+}
 async function createRootAlloc(connection, programId, payer, messageFee = 0n, title = "", onSent) {
   const programKey = new PublicKey(programId);
   const threadKeypair = Keypair.generate();
@@ -48610,58 +48604,49 @@ async function createRootAlloc(connection, programId, payer, messageFee = 0n, ti
     allocPda: deriveAllocPda(programKey, seed, 0).toBase58()
   };
 }
-function buildPrepareAllocInstruction(programId, payer, seed, allocSeq) {
-  const currentAllocPda = deriveAllocPda(programId, seed, allocSeq);
-  const newAllocPda = deriveAllocPda(programId, seed, allocSeq + 1);
-  const threadAccount = deriveThreadPda(programId, seed);
-  return new TransactionInstruction({
-    programId,
-    keys: [
-      { pubkey: payer, isSigner: true, isWritable: true },
-      { pubkey: currentAllocPda, isSigner: false, isWritable: true },
-      { pubkey: newAllocPda, isSigner: false, isWritable: true },
-      { pubkey: threadAccount, isSigner: false, isWritable: true },
-      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false }
-    ],
-    data: Buffer3.from(PrepareAllocInstr.serialize({
-      tag: Instruction.PrepareAlloc,
-      allocSeq
-    }))
-  });
-}
-function buildSweepAuthorFeesInstruction(programId, seed, threadAccount, authorWallet, shardIndices) {
+function buildCloseAccountInstruction(programId, payer, targetAccount, likesAccount) {
   const keys = [
-    { pubkey: threadAccount, isSigner: false, isWritable: false },
-    { pubkey: authorWallet, isSigner: true, isWritable: true }
+    signerMeta(payer),
+    writableMeta(targetAccount)
   ];
-  for (const idx of shardIndices) {
-    keys.push({
-      pubkey: deriveAuthorFeePda(programId, seed, idx),
-      isSigner: false,
-      isWritable: true
-    });
+  if (likesAccount) {
+    keys.push(writableMeta(likesAccount));
   }
   return new TransactionInstruction({
     programId,
     keys,
-    data: Buffer3.from(SweepAuthorFeesInstr.serialize({
-      tag: Instruction.SweepAuthorFees,
-      shardIndices: Uint8Array.from(shardIndices)
-    }))
+    data: Buffer3.from(TagOnlyInstr.serialize({ tag: Instruction.CloseAccount }))
   });
 }
-function buildCloseAccountInstruction(programId, payer, targetAccount, likesAccount) {
-  const keys = [
-    { pubkey: payer, isSigner: true, isWritable: true },
-    { pubkey: targetAccount, isSigner: false, isWritable: true }
-  ];
-  if (likesAccount) {
-    keys.push({ pubkey: likesAccount, isSigner: false, isWritable: true });
-  }
+function buildLikeContentInstruction(programId, payer, seed, allocSeq, slot, maxFee) {
+  const likesAccount = deriveLikesPda(programId, seed, allocSeq);
+  const contentAccount = deriveContentPda(programId, seed, allocSeq, slot);
+  const threadAccount = deriveThreadPda(programId, seed);
+  const settingsAccount = deriveSettingsPda(programId);
+  const treasuryShardIdx = randomTreasuryShard();
+  const authorFeeShardIdx = randomAuthorFeeShard();
+  const treasuryShard = deriveTreasuryShardPda(programId, treasuryShardIdx);
+  const authorFeeShard = deriveAuthorFeePda(programId, seed, authorFeeShardIdx);
   return new TransactionInstruction({
     programId,
-    keys,
-    data: Buffer3.from(TagOnlyInstr.serialize({ tag: Instruction.CloseAccount }))
+    keys: [
+      signerMeta(payer),
+      writableMeta(likesAccount),
+      readonlyMeta(contentAccount),
+      readonlyMeta(threadAccount),
+      readonlyMeta(settingsAccount),
+      writableMeta(treasuryShard),
+      writableMeta(authorFeeShard),
+      readonlyMeta(SystemProgram.programId)
+    ],
+    data: Buffer3.from(LikeContentInstr.serialize({
+      tag: Instruction.LikeContent,
+      allocSeq,
+      slot,
+      treasuryShardIdx,
+      authorFeeShardIdx,
+      maxFee
+    }))
   });
 }
 function buildInitThreadAccessInstruction(programId, authority, seed, enabled) {
@@ -48672,11 +48657,11 @@ function buildInitThreadAccessInstruction(programId, authority, seed, enabled) {
   return new TransactionInstruction({
     programId,
     keys: [
-      { pubkey: authority, isSigner: true, isWritable: true },
-      { pubkey: threadAccount, isSigner: false, isWritable: false },
-      { pubkey: accessAccount, isSigner: false, isWritable: true },
-      { pubkey: treasuryShard, isSigner: false, isWritable: true },
-      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false }
+      signerMeta(authority),
+      readonlyMeta(threadAccount),
+      writableMeta(accessAccount),
+      writableMeta(treasuryShard),
+      readonlyMeta(SystemProgram.programId)
     ],
     data: Buffer3.from(InitThreadAccessInstr.serialize({
       tag: Instruction.InitThreadAccess,
@@ -48689,8 +48674,8 @@ function buildSetThreadAccessInstruction(programId, authority, accessAccount, en
   return new TransactionInstruction({
     programId,
     keys: [
-      { pubkey: authority, isSigner: true, isWritable: true },
-      { pubkey: accessAccount, isSigner: false, isWritable: true }
+      signerMeta(authority),
+      writableMeta(accessAccount)
     ],
     data: Buffer3.from(SetThreadAccessInstr.serialize({
       tag: Instruction.SetThreadAccess,
@@ -48698,70 +48683,6 @@ function buildSetThreadAccessInstruction(programId, authority, accessAccount, en
     }))
   });
 }
-function buildAddToWhitelistInstruction(programId, authority, seed, wallet) {
-  const accessAccount = deriveAccessPda(programId, seed);
-  const entryAccount = deriveAccessEntryPda(programId, seed, wallet);
-  return new TransactionInstruction({
-    programId,
-    keys: [
-      { pubkey: authority, isSigner: true, isWritable: true },
-      { pubkey: accessAccount, isSigner: false, isWritable: true },
-      { pubkey: entryAccount, isSigner: false, isWritable: true },
-      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false }
-    ],
-    data: Buffer3.from(WalletArgInstr.serialize({
-      tag: Instruction.AddToWhitelist,
-      wallet: wallet.toBytes()
-    }))
-  });
-}
-function buildRemoveFromWhitelistInstruction(programId, authority, seed, wallet) {
-  const accessAccount = deriveAccessPda(programId, seed);
-  const entryAccount = deriveAccessEntryPda(programId, seed, wallet);
-  return new TransactionInstruction({
-    programId,
-    keys: [
-      { pubkey: authority, isSigner: true, isWritable: true },
-      { pubkey: accessAccount, isSigner: false, isWritable: true },
-      { pubkey: entryAccount, isSigner: false, isWritable: true },
-      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false }
-    ],
-    data: Buffer3.from(WalletArgInstr.serialize({
-      tag: Instruction.RemoveFromWhitelist,
-      wallet: wallet.toBytes()
-    }))
-  });
-}
-function buildSetMessageFeeInstruction(programId, authority, threadAccount, fee) {
-  return new TransactionInstruction({
-    programId,
-    keys: [
-      { pubkey: authority, isSigner: true, isWritable: true },
-      { pubkey: threadAccount, isSigner: false, isWritable: true }
-    ],
-    data: Buffer3.from(FeeU64Instr.serialize({ tag: Instruction.SetMessageFee, fee }))
-  });
-}
-function buildSetLikeFeeInstruction(programId, authority, threadAccount, fee) {
-  return new TransactionInstruction({
-    programId,
-    keys: [
-      { pubkey: authority, isSigner: true, isWritable: true },
-      { pubkey: threadAccount, isSigner: false, isWritable: true }
-    ],
-    data: Buffer3.from(FeeU64Instr.serialize({ tag: Instruction.SetLikeFee, fee }))
-  });
-}
-function buildSetEntryFeeInstruction(programId, authority, accessAccount, fee) {
-  return new TransactionInstruction({
-    programId,
-    keys: [
-      { pubkey: authority, isSigner: true, isWritable: true },
-      { pubkey: accessAccount, isSigner: false, isWritable: true }
-    ],
-    data: Buffer3.from(FeeU64Instr.serialize({ tag: Instruction.SetEntryFee, fee }))
-  });
-}
 function buildRequestAccessInstruction(programId, payer, seed) {
   const accessAccount = deriveAccessPda(programId, seed);
   const entryAccount = deriveAccessEntryPda(programId, seed, payer);
@@ -48774,14 +48695,14 @@ function buildRequestAccessInstruction(programId, payer, seed) {
   return new TransactionInstruction({
     programId,
     keys: [
-      { pubkey: payer, isSigner: true, isWritable: true },
-      { pubkey: accessAccount, isSigner: false, isWritable: true },
-      { pubkey: entryAccount, isSigner: false, isWritable: true },
-      { pubkey: threadAccount, isSigner: false, isWritable: false },
-      { pubkey: settingsAccount, isSigner: false, isWritable: false },
-      { pubkey: treasuryShard, isSigner: false, isWritable: true },
-      { pubkey: authorFeeShard, isSigner: false, isWritable: true },
-      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false }
+      signerMeta(payer),
+      writableMeta(accessAccount),
+      writableMeta(entryAccount),
+      readonlyMeta(threadAccount),
+      readonlyMeta(settingsAccount),
+      writableMeta(treasuryShard),
+      writableMeta(authorFeeShard),
+      readonlyMeta(SystemProgram.programId)
     ],
     data: Buffer3.from(RequestAccessInstr.serialize({
       tag: Instruction.RequestAccess,
@@ -48790,111 +48711,94 @@ function buildRequestAccessInstruction(programId, payer, seed) {
     }))
   });
 }
-function buildLikeContentInstruction(programId, payer, seed, allocSeq, slot, maxFee) {
-  const likesAccount = deriveLikesPda(programId, seed, allocSeq);
-  const contentAccount = deriveContentPda(programId, seed, allocSeq, slot);
-  const threadAccount = deriveThreadPda(programId, seed);
-  const settingsAccount = deriveSettingsPda(programId);
-  const treasuryShardIdx = randomTreasuryShard();
-  const authorFeeShardIdx = randomAuthorFeeShard();
-  const treasuryShard = deriveTreasuryShardPda(programId, treasuryShardIdx);
-  const authorFeeShard = deriveAuthorFeePda(programId, seed, authorFeeShardIdx);
-  return new TransactionInstruction({
-    programId,
-    keys: [
-      { pubkey: payer, isSigner: true, isWritable: true },
-      { pubkey: likesAccount, isSigner: false, isWritable: true },
-      { pubkey: contentAccount, isSigner: false, isWritable: false },
-      { pubkey: threadAccount, isSigner: false, isWritable: false },
-      { pubkey: settingsAccount, isSigner: false, isWritable: false },
-      { pubkey: treasuryShard, isSigner: false, isWritable: true },
-      { pubkey: authorFeeShard, isSigner: false, isWritable: true },
-      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false }
-    ],
-    data: Buffer3.from(LikeContentInstr.serialize({
-      tag: Instruction.LikeContent,
-      allocSeq,
-      slot,
-      treasuryShardIdx,
-      authorFeeShardIdx,
-      maxFee
-    }))
-  });
-}
-function buildAddToBlacklistInstruction(programId, authority, seed, wallet) {
+function buildAclEntryInstruction(tag, programId, authority, seed, wallet) {
   const accessAccount = deriveAccessPda(programId, seed);
   const entryAccount = deriveAccessEntryPda(programId, seed, wallet);
   return new TransactionInstruction({
     programId,
     keys: [
-      { pubkey: authority, isSigner: true, isWritable: true },
-      { pubkey: accessAccount, isSigner: false, isWritable: true },
-      { pubkey: entryAccount, isSigner: false, isWritable: true },
-      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false }
+      signerMeta(authority),
+      writableMeta(accessAccount),
+      writableMeta(entryAccount),
+      readonlyMeta(SystemProgram.programId)
     ],
     data: Buffer3.from(WalletArgInstr.serialize({
-      tag: Instruction.AddToBlacklist,
+      tag,
       wallet: wallet.toBytes()
     }))
   });
 }
+function buildAddToWhitelistInstruction(programId, authority, seed, wallet) {
+  return buildAclEntryInstruction(Instruction.AddToWhitelist, programId, authority, seed, wallet);
+}
+function buildRemoveFromWhitelistInstruction(programId, authority, seed, wallet) {
+  return buildAclEntryInstruction(Instruction.RemoveFromWhitelist, programId, authority, seed, wallet);
+}
+function buildAddToBlacklistInstruction(programId, authority, seed, wallet) {
+  return buildAclEntryInstruction(Instruction.AddToBlacklist, programId, authority, seed, wallet);
+}
 function buildRemoveFromBlacklistInstruction(programId, authority, seed, wallet) {
-  const accessAccount = deriveAccessPda(programId, seed);
-  const entryAccount = deriveAccessEntryPda(programId, seed, wallet);
+  return buildAclEntryInstruction(Instruction.RemoveFromBlacklist, programId, authority, seed, wallet);
+}
+function buildAddToFeeWhitelistInstruction(programId, authority, seed, wallet) {
+  return buildAclEntryInstruction(Instruction.AddToFeeWhitelist, programId, authority, seed, wallet);
+}
+function buildRemoveFromFeeWhitelistInstruction(programId, authority, seed, wallet) {
+  return buildAclEntryInstruction(Instruction.RemoveFromFeeWhitelist, programId, authority, seed, wallet);
+}
+var FEE_TAG = {
+  base: Instruction.SetBaseFee,
+  authorCut: Instruction.SetAuthorFeeCut,
+  entryCut: Instruction.SetEntryCut,
+  likeCut: Instruction.SetLikeCut
+};
+function buildSetMessageFeeInstruction(programId, authority, threadAccount, fee) {
   return new TransactionInstruction({
     programId,
     keys: [
-      { pubkey: authority, isSigner: true, isWritable: true },
-      { pubkey: accessAccount, isSigner: false, isWritable: true },
-      { pubkey: entryAccount, isSigner: false, isWritable: true },
-      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false }
+      signerMeta(authority),
+      writableMeta(threadAccount)
     ],
-    data: Buffer3.from(WalletArgInstr.serialize({
-      tag: Instruction.RemoveFromBlacklist,
-      wallet: wallet.toBytes()
-    }))
+    data: Buffer3.from(FeeU64Instr.serialize({ tag: Instruction.SetMessageFee, fee }))
   });
 }
-function buildAddToFeeWhitelistInstruction(programId, authority, seed, wallet) {
-  const accessAccount = deriveAccessPda(programId, seed);
-  const entryAccount = deriveAccessEntryPda(programId, seed, wallet);
+function buildSetLikeFeeInstruction(programId, authority, threadAccount, fee) {
   return new TransactionInstruction({
     programId,
     keys: [
-      { pubkey: authority, isSigner: true, isWritable: true },
-      { pubkey: accessAccount, isSigner: false, isWritable: true },
-      { pubkey: entryAccount, isSigner: false, isWritable: true },
-      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false }
+      signerMeta(authority),
+      writableMeta(threadAccount)
     ],
-    data: Buffer3.from(WalletArgInstr.serialize({
-      tag: Instruction.AddToFeeWhitelist,
-      wallet: wallet.toBytes()
-    }))
+    data: Buffer3.from(FeeU64Instr.serialize({ tag: Instruction.SetLikeFee, fee }))
   });
 }
-function buildRemoveFromFeeWhitelistInstruction(programId, authority, seed, wallet) {
-  const accessAccount = deriveAccessPda(programId, seed);
-  const entryAccount = deriveAccessEntryPda(programId, seed, wallet);
+function buildSetEntryFeeInstruction(programId, authority, accessAccount, fee) {
   return new TransactionInstruction({
     programId,
     keys: [
-      { pubkey: authority, isSigner: true, isWritable: true },
-      { pubkey: accessAccount, isSigner: false, isWritable: true },
-      { pubkey: entryAccount, isSigner: false, isWritable: true },
-      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false }
+      signerMeta(authority),
+      writableMeta(accessAccount)
     ],
-    data: Buffer3.from(WalletArgInstr.serialize({
-      tag: Instruction.RemoveFromFeeWhitelist,
-      wallet: wallet.toBytes()
+    data: Buffer3.from(FeeU64Instr.serialize({ tag: Instruction.SetEntryFee, fee }))
+  });
+}
+function buildSweepAuthorFeesInstruction(programId, seed, threadAccount, authorWallet, shardIndices) {
+  const keys = [
+    readonlyMeta(threadAccount),
+    signerMeta(authorWallet)
+  ];
+  for (const idx of shardIndices) {
+    keys.push(writableMeta(deriveAuthorFeePda(programId, seed, idx)));
+  }
+  return new TransactionInstruction({
+    programId,
+    keys,
+    data: Buffer3.from(SweepAuthorFeesInstr.serialize({
+      tag: Instruction.SweepAuthorFees,
+      shardIndices: Uint8Array.from(shardIndices)
     }))
   });
 }
-var FEE_TAG = {
-  base: Instruction.SetBaseFee,
-  authorCut: Instruction.SetAuthorFeeCut,
-  entryCut: Instruction.SetEntryCut,
-  likeCut: Instruction.SetLikeCut
-};
 function buildFollowInstruction(tag, opts) {
   const { programId, user, seed } = opts;
   const threadAccount = deriveThreadPda(programId, seed);
@@ -48903,11 +48807,11 @@ function buildFollowInstruction(tag, opts) {
   return new TransactionInstruction({
     programId,
     keys: [
-      { pubkey: user, isSigner: true, isWritable: true },
-      { pubkey: followRegistry, isSigner: false, isWritable: true },
-      { pubkey: followerShard, isSigner: false, isWritable: true },
-      { pubkey: threadAccount, isSigner: false, isWritable: false },
-      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false }
+      signerMeta(user),
+      writableMeta(followRegistry),
+      writableMeta(followerShard),
+      readonlyMeta(threadAccount),
+      readonlyMeta(SystemProgram.programId)
     ],
     data: Buffer3.from(TagOnlyInstr.serialize({ tag }))
   });
@@ -48981,6 +48885,18 @@ async function sendTransactions(payer, txs) {
   }
   return sigs;
 }
+async function trySendBestEffort(payer, tx) {
+  try {
+    const { connection } = loadConfig();
+    tx.feePayer = payer.publicKey;
+    const { blockhash } = await connection.getLatestBlockhash("confirmed");
+    tx.recentBlockhash = blockhash;
+    tx.sign(payer);
+    return await connection.sendRawTransaction(tx.serialize());
+  } catch {
+    return null;
+  }
+}
 function explorerTx(signature) {
   const { rpcUrl } = loadConfig();
   const cluster = rpcUrl.includes("devnet") ? "?cluster=devnet" : rpcUrl.includes("testnet") ? "?cluster=testnet" : rpcUrl.includes("localhost") || rpcUrl.includes("127.0.0.1") ? "?cluster=custom" : "";
@@ -49113,7 +49029,7 @@ function registerMessagingTools(server) {
     "send_message",
     {
       title: "Send message",
-      description: "Post a text message to a channel as the agent wallet. Handles fees, slot selection and chunking of long messages automatically.",
+      description: "Post a text message to a channel as the agent wallet. Handles fees, slot selection and chunking of long messages automatically. Posting is decoupled from growing the alloc chain: after the post confirms, a best-effort page extension is fired when the tail page is filling up (its failure never affects the post).",
       inputSchema: {
         channel: channelArg,
         text: external_exports.string().min(1).describe("Message text (UTF-8, up to 8192 bytes)."),
@@ -49135,10 +49051,19 @@ function registerMessagingTools(server) {
         replyTo
       );
       const signatures = await sendTransactions(payer, txs);
+      let extendSignature = null;
+      try {
+        const extendTx = await buildExtendAllocTransaction(connection, programId, payer.publicKey, seed);
+        if (extendTx) extendSignature = await trySendBestEffort(payer, extendTx);
+      } catch {
+        extendSignature = null;
+      }
       return jsonResult({
         channel: seedToAddress(seed),
         signatures,
-        explorer: signatures.map(explorerTx)
+        explorer: signatures.map(explorerTx),
+        extendSignature,
+        extendExplorer: extendSignature ? explorerTx(extendSignature) : null
       });
     })
   );
@@ -49180,7 +49105,7 @@ function registerMessagingTools(server) {
     "prepare_alloc",
     {
       title: "Prepare alloc",
-      description: "Pre-create the next alloc page in a channel so there are free slots ahead of demand. Mostly useful for high-traffic channels.",
+      description: "Manually pre-create the next alloc page (allocSeq + 1) in a channel so there are free slots ahead of demand. send_message already does this best-effort; use this to force-extend a high-traffic channel. Racy by design: it fails with InvalidAllocSeq if the chain tail moved on.",
       inputSchema: {
         channel: channelArg,
         allocSeq: external_exports.number().int().describe("Current alloc seq to extend from.")
@@ -49644,7 +49569,7 @@ function registerThreadAdminTools(server) {
 async function main() {
   const config2 = loadConfig();
   const wallet = loadWallet();
-  const server = new McpServer({ name: "txtcel-mcp", version: "0.1.2" });
+  const server = new McpServer({ name: "txtcel-mcp", version: "0.2.0" });
   registerMessagingTools(server);
   registerFollowTools(server);
   registerReadTools(server);