@dfm-fi/agent 0.2.1212 → 0.2.1423

package/dist/mcp-server.js

@@ -54,11 +54,8 @@ import { z } from 'zod';
 import { loadConfig } from './config.js';
 import { SiwsSession } from './session.js';
 import { DfmApiClient } from './api-client.js';
-import { runDeposit, runRedeem } from './zap-v2-flow.js';
-import { runLaunchVault } from './create-flow.js';
-import { isKeylessMode, shouldExecuteViaAppWallet, KEYLESS_SETUP_HINT, } from './keyless.js';
-import { runCancel, runUpdateEnvelope } from './recovery-flow.js';
-import { runTransferAdmin, runInitRebalancer, runRebalanceToTargets, runUpdateVaultAssets, runAcceptAdminTransfer, runUpdateVaultPolicy, reconcileKeylessUpdateVaultPolicy, } from './manager-flow.js';
+import { isKeylessMode, shouldExecuteViaAppWallet, executeAppWalletWrite, KEYLESS_SETUP_HINT, } from './keyless.js';
+import { runAcceptAdminTransfer, runUpdateVaultPolicy, reconcileKeylessUpdateVaultPolicy, } from './manager-flow.js';
 import { submitSignedTx } from './submit.js';
 import { signBase64Transaction } from './signing.js';
 import { buildWalletIdentity, resolveZapStatusWallet, withActingWalletAlias, withPortfolioWalletAlias, } from './wallet-identity.js';
@@ -230,7 +227,14 @@ server.registerTool('discover_tokens', {
         assetClass: z
             .string()
             .optional()
-            .describe('Optional filter: LST | Spot | FUN'),
+            // Was "LST | Spot | FUN" — three of the six the API accepts, so an
+            // external agent could not narrow to stablecoins, yield-bearing
+            // tokens or tokenized RWAs even though `?class=` has taken all three
+            // for months. Same list Kim's in-app registry offers, deliberately:
+            // two agent surfaces answering the same question differently is the
+            // drift this alignment pass exists to remove.
+            .describe('Optional filter: lst (liquid staking) | spot (regular tokens) | ' +
+            'fun (pump.fun) | stable | ybt (yield-bearing) | rwa (tokenized real-world assets)'),
     },
     annotations: { readOnlyHint: true, openWorldHint: true },
 }, async ({ query, assetClass }) => {
@@ -515,15 +519,10 @@ function writeGate() {
  * to install the very keypair the credential model exists to avoid.
  */
 function keylessUnsupported(tool) {
-    if (!isKeylessMode(config))
+    // Explicit owner-signed top-ups are the sole transaction-signing exception.
+    if (tool === 'app_wallet_fund' && !isKeylessMode(config))
         return null;
-    return errText(`${tool} is not available in KEYLESS mode (a DFM_API_KEY with no local keypair). ` +
-        `It has no server-side autonomous path yet, so there is nothing here that can ` +
-        `sign it. Keyless writes today: deposit, redeem, launch_vault, update_vault_assets, ` +
-        `update_vault_policy, rebalance_to_targets, zap_v2_cancel, ` +
-        `zap_v2_update_envelope. ` +
-        `For this one, either run the MCP with a local keypair, or drive it from the web app ` +
-        `where you sign with your own wallet.`);
+    return errText(`${tool} has no app-wallet signing path in this agent. Local signing cannot override that requirement.`);
 }
 /**
  * Resolve both wallet roles from the server on each call. The app wallet may
@@ -540,49 +539,13 @@ async function resolveWalletIdentity() {
         return buildWalletIdentity(null, localSignIn);
     }
 }
-/**
- * The app wallet's status, read FRESH on every ask.
- *
- * It used to be cached for the process lifetime, on the reasoning that the
- * answer "cannot change mid-session without the operator restarting". This
- * same server exposes `app_wallet_rearm`, so it plainly can: read `revoked`,
- * re-arm, and the cache keeps serving the stale value while the new wallet sits
- * ACTIVE — every later write falls to the local signer until a restart. Under
- * WHO PAYS that is not a missed optimisation, it is signing with the wrong
- * wallet, and the chain rejects it because the app wallet owns the escrow.
- *
- * One extra round trip per money write is the correct price.
- *
- * It does NOT swallow a failed lookup. There is a real difference between "the
- * server answered, and there is no app wallet" (null → sign locally) and "I
- * could not find out who pays" (throw). Mapping the second onto the first —
- * which a `.catch(() => null)` here did — means a 500 or a timeout silently
- * re-selects the external wallet in the mixed setup: the exact bug this rule
- * exists to close, reappearing on a bad network moment. The callers all sit
- * inside a try/catch that reports the failure, which is the right outcome:
- * refuse to guess rather than sign with a wallet chosen blind.
- */
-function readAppWalletStatus() {
-    return api.getOperatingWallet().then((op) => op?.status ?? null);
-}
 async function keylessWrite(tool, args) {
-    // WHO PAYS. Not "is this process keyless" any more: an active app wallet is
-    // the lane even when a local keypair is present, because the keypair wallet is
-    // not where the user's money is. See keyless.ts for the mainnet measurement
-    // that forced this.
-    const viaAppWallet = shouldExecuteViaAppWallet(config, await readAppWalletStatus());
-    if (!viaAppWallet)
-        return null;
     try {
-        const res = await api.executeViaOperatingWallet(tool, args);
-        return res ? text(res) : null;
+        return text(await executeAppWalletWrite(config, api, tool, args));
     }
     catch (e) {
         const message = e.message;
-        // Validation/transaction errors are not fixed by reconnecting or funding a
-        // wallet. Only append the setup checklist when the failure actually points
-        // at auth, custody, activation, or permission setup.
-        const setupRelevant = /DFM API (401|403|409|501)\b|operating wallet|read-only|allowedOps|custody unavailable/i.test(message);
+        const setupRelevant = /OPERATING_WALLET_REQUIRED|DFM API (401|403|409|501)\b|operating wallet|read-only|allowedOps|custody unavailable/i.test(message);
         return errText(`${tool} failed (app wallet): ${message}${setupRelevant ? `\n${KEYLESS_SETUP_HINT}` : ''}`);
     }
 }
@@ -592,7 +555,11 @@ server.registerTool('launch_vault', {
     description: 'REAL-MONEY (gated). Create a new DTF vault. WHO PAYS: your APP WALLET ' +
         '(the Privy operating wallet) signs and funds this whenever you have an ' +
         'active one — that is where your money is, and it becomes the vault admin. ' +
-        'Only an identity with no app wallet falls back to a local keypair. Check ' +
+        'An app wallet is REQUIRED here: with no active one this tool refuses ' +
+        'instead of signing with a local keypair, because the creator is fixed ' +
+        'on-chain forever and is what registers the fund to you — a launch signed ' +
+        'by any other wallet is a fund nobody can claim. Anyone can get an app ' +
+        'wallet (no allowlist); this is an identity rule, not a permission one. Check ' +
         '`app_wallet` first if a write is refused for funds. `assets` is the basket — each ' +
         '{ mint, symbol, allocationBps }; allocationBps MUST sum to exactly 10000, ' +
         '≤10 assets (mainnet cap). Live factory/fund-tier rules decide mint eligibility; ' +
@@ -600,7 +567,9 @@ server.registerTool('launch_vault', {
         'and read live by DFM — the creator cannot set them. After the vault is recorded, ' +
         'the share mint automatically gets ' +
         'Metaplex token metadata (name/symbol/uri) so explorers + wallets show the ' +
-        'DTF instead of "Unknown Token" (#47, best-effort + non-fatal). ' +
+        'DTF instead of "Unknown Token" (#47, best-effort + non-fatal); pass `metadata:false` ' +
+        'to skip that tx (~0.015 SOL of unrecoverable rent; SOL floor ~0.03 instead of ~0.045) ' +
+        'and attach it later from the vault page. ' +
         'Returns the vault address — fund the first deposit ≥ ~$12.',
     inputSchema: {
         name: z.string().min(1).max(32),
@@ -619,45 +588,27 @@ server.registerTool('launch_vault', {
             .max(10),
         category: z.number().int().optional(),
         description: z.string().max(200).optional(),
+        // Opt-out, never a default: the metadata tx is ~0.015 SOL of rent that
+        // never comes back, and the SOL floor drops from ~0.045 to ~0.03 without
+        // it. The vault page can attach it later (creator-signed).
+        metadata: z.boolean().optional(),
     },
     annotations: { title: 'DFM launch vault', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
 }, 
 // REVIEW: real-money path — parent must review before enabling.
-async ({ name, symbol, assets, category, description }) => {
+async ({ name, symbol, assets, category, description, metadata }) => {
     const gate = writeGate();
     if (!gate.ok)
         return gate.result;
-    const keyless = await keylessWrite('launch_vault', {
-        name, symbol, assets, category, description,
-    });
-    if (keyless)
-        return keyless;
-    try {
-        const res = await runLaunchVault(config, api, {
-            name,
-            symbol,
-            // map the agent-facing `allocationBps` → the API's `mintBps`.
-            assets: assets.map((a) => ({
-                mint: a.mint,
-                symbol: a.symbol,
-                mintBps: a.allocationBps,
-            })),
-            category,
-            description,
-        });
-        return text(res);
-    }
-    catch (e) {
-        return errText(`launch_vault failed: ${e.message}`);
-    }
+    return keylessWrite('launch_vault', { name, symbol, assets, category, description, ...(metadata === false && { metadata }) });
 });
 // ─── WRITE TOOL: deposit (zap-in) ─────────────────────────────────────────
 server.registerTool('deposit', {
     title: 'Deposit USDC → vault (zap-in lifecycle)',
     description: 'REAL-MONEY (gated). Drive a full zap-v2 deposit: open (pull USDC, pin plan) ' +
         '→ wait while the backend orchestrator cranks the USDC→asset swaps → close ' +
-        '(mint shares). The agent signs only the two user-side boundary TXs locally ' +
-        'with its test keypair. `usdcAmount` is RAW 6-decimal units (e.g. "12000000" ' +
+        '(mint shares). The server signs the boundary transactions with your app wallet. ' +
+        ' `usdcAmount` is RAW 6-decimal units (e.g. "12000000" ' +
         '= $12). First deposit into a vault must clear ~$12 after slippage.',
     inputSchema: {
         vault: z.string().regex(BASE58, 'Invalid base58 vault address'),
@@ -672,35 +623,19 @@ server.registerTool('deposit', {
     annotations: { title: 'DFM zap-in deposit', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
 }, 
 // REVIEW: real-money path — parent must review before enabling.
-async ({ vault, usdcAmount, slippageBps, expirySecs, pollTimeoutSecs }) => {
+async ({ vault, usdcAmount, slippageBps, expirySecs }) => {
     const gate = writeGate();
     if (!gate.ok)
         return gate.result;
-    const keyless = await keylessWrite('deposit', { vault, usdcAmount, slippageBps, expirySecs });
-    if (keyless)
-        return keyless;
-    try {
-        const user = session.walletAddress;
-        const res = await runDeposit(config, api, user, vault, usdcAmount, {
-            slippageBps,
-            expirySecs,
-            poll: pollTimeoutSecs ? { timeoutSecs: pollTimeoutSecs } : undefined,
-        });
-        return text(res);
-    }
-    catch (e) {
-        return errText(`deposit failed: ${e.message}\n` +
-            `If the escrow is still open, inspect it with zap_status, then recover with ` +
-            `zap_v2_update_envelope (loosen floors) or zap_v2_cancel (return holdings).`);
-    }
+    return keylessWrite('deposit', { vault, usdcAmount, slippageBps, expirySecs });
 });
 // ─── WRITE TOOL: redeem (zap-out) ─────────────────────────────────────────
 server.registerTool('redeem', {
     title: 'Redeem shares → USDC (zap-out lifecycle)',
     description: 'REAL-MONEY (gated). Drive a full zap-v2 redeem: open (burn shares → escrow ' +
         'basket, oracle-free pro-rata) → wait while the orchestrator cranks the ' +
-        'asset→USDC swaps → close (exit fee, pay net USDC). The agent signs only the ' +
-        'two boundary TXs locally. `shares` is RAW 6-decimal units.',
+        'asset→USDC swaps → close (exit fee, pay net USDC). Your app wallet signs ' +
+        'both boundary transactions on the server. `shares` is RAW 6-decimal units.',
     inputSchema: {
         vault: z.string().regex(BASE58, 'Invalid base58 vault address'),
         shares: rawShares6dp,
@@ -714,27 +649,11 @@ server.registerTool('redeem', {
     annotations: { title: 'DFM zap-out redeem', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
 }, 
 // REVIEW: real-money path — parent must review before enabling.
-async ({ vault, shares, slippageBps, expirySecs, pollTimeoutSecs }) => {
+async ({ vault, shares, slippageBps, expirySecs }) => {
     const gate = writeGate();
     if (!gate.ok)
         return gate.result;
-    const keyless = await keylessWrite('redeem', { vault, shares, slippageBps, expirySecs });
-    if (keyless)
-        return keyless;
-    try {
-        const user = session.walletAddress;
-        const res = await runRedeem(config, api, user, vault, shares, {
-            slippageBps,
-            expirySecs,
-            poll: pollTimeoutSecs ? { timeoutSecs: pollTimeoutSecs } : undefined,
-        });
-        return text(res);
-    }
-    catch (e) {
-        return errText(`redeem failed: ${e.message}\n` +
-            `If the escrow is still open, inspect it with zap_status, then recover with ` +
-            `zap_v2_update_envelope or zap_v2_cancel.`);
-    }
+    return keylessWrite('redeem', { vault, shares, slippageBps, expirySecs });
 });
 // ─── WRITE TOOLS: stall recovery (cancel / update-envelope) ───────────────
 // Fully wired in BOTH lanes (#77 ask 2): an ACTIVE app wallet executes them
@@ -759,29 +678,7 @@ async ({ vault }) => {
     const gate = writeGate();
     if (!gate.ok)
         return gate.result;
-    try {
-        // #77 ask 2 — a dead-legged AGENT deposit used to have no way out: this
-        // refused in keyless mode ("no server-side autonomous path yet"), so an
-        // escrow the agent itself opened could only be recovered by ops. That was
-        // a gap in WIRING, not a missing capability — `ConfirmService.buildFor`
-        // has built `zap_v2_cancel` for the operating wallet all along.
-        //
-        // Routed through `keylessWrite`, NOT `isKeylessMode`. WHO PAYS: an ACTIVE
-        // app wallet is the lane even when a local keypair exists, because the
-        // escrow belongs to the wallet that opened the deposit. Gating on
-        // `isKeylessMode` (which requires NO local keypair) broke the exact mixed
-        // case this fix exists for — API key + active app wallet + local keypair —
-        // by falling through to a local signer that is not the escrow's owner.
-        const viaWallet = await keylessWrite('zap_v2_cancel', { vault });
-        if (viaWallet)
-            return viaWallet;
-        const res = await runCancel(config, api, session.walletAddress, vault);
-        return text(res);
-    }
-    catch (e) {
-        return errText(`zap_v2_cancel failed: ${e.message}` +
-            (isKeylessMode(config) ? `\n${KEYLESS_SETUP_HINT}` : ''));
-    }
+    return keylessWrite('zap_v2_cancel', { vault });
 });
 server.registerTool('zap_v2_update_envelope', {
     title: 'Loosen pinned floors on a stalled zap-v2 escrow',
@@ -804,31 +701,7 @@ async ({ vault, loosenPct, newSlippageBps, extendSecs }) => {
     const gate = writeGate();
     if (!gate.ok)
         return gate.result;
-    try {
-        // #77 ask 2 — the OTHER half of agent self-recovery. A stalled escrow has
-        // two exits: loosen the pinned floors so the leg can still fill, or cancel
-        // and take the holdings back. Wiring only the cancel would leave the agent
-        // able to abandon a deposit but never to rescue one — and loosening is the
-        // outcome the depositor actually wants. Same WHO PAYS routing as above.
-        const viaWallet = await keylessWrite('zap_v2_update_envelope', {
-            vault,
-            loosenPct,
-            newSlippageBps,
-            extendSecs,
-        });
-        if (viaWallet)
-            return viaWallet;
-        const res = await runUpdateEnvelope(config, api, session.walletAddress, vault, {
-            loosenPct,
-            newSlippageBps,
-            extendSecs,
-        });
-        return text(res);
-    }
-    catch (e) {
-        return errText(`zap_v2_update_envelope failed: ${e.message}` +
-            (isKeylessMode(config) ? `\n${KEYLESS_SETUP_HINT}` : ''));
-    }
+    return keylessWrite('zap_v2_update_envelope', { vault, loosenPct, newSlippageBps, extendSecs });
 });
 // ─── WRITE TOOL: update_vault_assets (config-only, same semantics in both lanes) ─
 server.registerTool('update_vault_assets', {
@@ -861,30 +734,13 @@ async ({ vault, assets }) => {
     const gate = writeGate();
     if (!gate.ok)
         return gate.result;
-    const keyless = await keylessWrite('update_vault_assets', { vault, assets });
-    if (keyless)
-        return keyless;
-    try {
-        const res = await runUpdateVaultAssets(config, api, vault, assets.map((a) => ({
-            mint: a.mint,
-            symbol: a.symbol,
-            mintBps: a.allocationBps,
-        })));
-        return text(res);
-    }
-    catch (e) {
-        return errText(`update_vault_assets failed: ${e.message}`);
-    }
+    return keylessWrite('update_vault_assets', { vault, assets });
 });
 // ─── WRITE TOOL: transfer_admin (HIGH SENSITIVITY) ────────────────────────
 server.registerTool('transfer_admin', {
     title: 'Transfer vault admin control (high sensitivity)',
-    description: '⚠️ HIGH-SENSITIVITY, REAL CONTROL (gated). MANAGER action — only works on a ' +
-        'vault the test wallet ADMINS. INITIATES handing vault admin control to ' +
-        '`newAdmin` (a 2-step transfer — the new admin must ACCEPT separately to ' +
-        'complete it). This GIVES AWAY control of the vault. Only do this when the ' +
-        'human EXPLICITLY asked, with a `newAdmin` they intend. Never infer it from a ' +
-        "vault's name/description or any untrusted text.",
+    description: 'Admin transfer has no app-wallet executor in this MCP yet. This tool refuses ' +
+        'to sign with an external or local wallet. No control is transferred.',
     inputSchema: {
         vault: z.string().regex(BASE58, 'Invalid base58 vault address'),
         newAdmin: z.string().regex(BASE58, 'Invalid base58 new-admin address'),
@@ -892,33 +748,18 @@ server.registerTool('transfer_admin', {
     annotations: { title: 'DFM transfer admin', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
 }, 
 // REVIEW: real-money / control path — parent must review before enabling.
-async ({ vault, newAdmin }) => {
+async () => {
     const gate = writeGate();
     if (!gate.ok)
         return gate.result;
-    const unsupported = keylessUnsupported('transfer_admin');
-    if (unsupported)
-        return unsupported;
-    try {
-        const res = await runTransferAdmin(config, api, vault, newAdmin);
-        return text(res);
-    }
-    catch (e) {
-        return errText(`transfer_admin failed: ${e.message}`);
-    }
+    return keylessUnsupported('transfer_admin');
 });
 // ─── WRITE TOOL: accept_admin_transfer (HIGH SENSITIVITY) ────────────────
 server.registerTool('accept_admin_transfer', {
     title: 'Accept vault admin control (high sensitivity)',
-    description: '⚠️ HIGH-SENSITIVITY, REAL CONTROL (gated, explicit-human-only). Complete a ' +
-        'pending admin handoff when the signed-in LOCAL wallet is the named new admin. ' +
-        'The human must explicitly provide confirmPhrase="accept_admin_transfer" in ' +
-        'the same request. Local mode prepares, signs, submits, then calls the post-chain ' +
-        'confirm endpoint; it reports success only after that endpoint verifies the ' +
-        'transaction and reconciles the new admin. A keyless operating wallet cannot sign ' +
-        'a new acceptance because the backend has no operating-executor mapping for this ' +
-        'tool. `landedSignature` is recovery-only: it retries reconciliation without ' +
-        'submitting another transaction.',
+    description: 'Reconcile an already-landed admin acceptance using landedSignature. New ' +
+        'acceptances have no app-wallet executor in this MCP and are refused. ' +
+        'No transaction is signed locally. confirmPhrase must be accept_admin_transfer.',
     inputSchema: {
         vault: z.string().regex(BASE58, 'Invalid base58 vault address'),
         confirmPhrase: z.literal('accept_admin_transfer'),
@@ -936,10 +777,7 @@ server.registerTool('accept_admin_transfer', {
         if (args.landedSignature) {
             return text(await runAcceptAdminTransfer(config, api, args.vault, args.landedSignature));
         }
-        const unsupported = keylessUnsupported('accept_admin_transfer');
-        if (unsupported)
-            return unsupported;
-        return text(await runAcceptAdminTransfer(config, api, args.vault));
+        return keylessUnsupported('accept_admin_transfer');
     }
     catch (e) {
         return errText(`accept_admin_transfer failed: ${e.message}`);
@@ -996,22 +834,11 @@ server.registerTool('update_vault_policy', {
         if (args.landedSignature) {
             return text(await runUpdateVaultPolicy(config, api, args.vault, policy, args.landedSignature));
         }
-        // WHO PAYS, not `isKeylessMode`. An ACTIVE app wallet is the lane even
-        // when a local keypair exists — it is the vault's admin in that setup, so
-        // a locally-signed policy update would be rejected on-chain. This cannot
-        // use `keylessWrite` because it needs the RAW result to reconcile against,
-        // so it shares the predicate rather than the wrapper.
-        if (shouldExecuteViaAppWallet(config, await readAppWalletStatus())) {
-            const result = await api.executeViaOperatingWallet('update_vault_policy', {
-                vault: args.vault,
-                ...policy,
-            });
-            if (!result) {
-                return errText('update_vault_policy did not enter the configured keyless lane.');
-            }
-            return text(await reconcileKeylessUpdateVaultPolicy(api, args.vault, policy, result));
-        }
-        return text(await runUpdateVaultPolicy(config, api, args.vault, policy));
+        const result = await executeAppWalletWrite(config, api, 'update_vault_policy', {
+            vault: args.vault,
+            ...policy,
+        });
+        return text(await reconcileKeylessUpdateVaultPolicy(api, args.vault, policy, result));
     }
     catch (e) {
         return errText(`update_vault_policy failed: ${e.message}` +
@@ -1050,6 +877,47 @@ server.registerTool('app_wallet_withdraw', {
         return errText(`app_wallet_withdraw failed: ${e.message}`);
     }
 });
+server.registerTool('list_app_wallet_assets', {
+    title: 'Everything the app wallet holds',
+    description: 'EVERY token in your app wallet — DTF shares included — with amount, decimals ' +
+        'and USD value. `app_wallet` reports the USDC + SOL float only, so it cannot ' +
+        'see a single share. Call this before proposing a withdrawal: it is where the ' +
+        'exact mint and the exact raw balance come from.',
+    inputSchema: {},
+    annotations: { title: 'DFM app wallet assets', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+}, async () => {
+    try {
+        return text(await api.listAppWalletAssets());
+    }
+    catch (e) {
+        return errText(`list_app_wallet_assets failed: ${e.message}`);
+    }
+});
+server.registerTool('withdraw_asset', {
+    title: 'Withdraw one token to its owner',
+    description: 'REAL-MONEY (gated). Send ONE mint from the app wallet back to the OWNER wallet ' +
+        '(the signed-in identity) — fund shares included, which app_wallet_withdraw ' +
+        'cannot move (it sweeps only USDC + SOL). The destination is pinned SERVER-SIDE ' +
+        'to your own wallet: you choose WHAT moves, never where it goes. `amount` is in ' +
+        'RAW base units (a 9-decimal token does not survive a UI float) — omit it to ' +
+        'send the whole balance. Read the mint and balance from list_app_wallet_assets ' +
+        'first; a mint the wallet does not hold is an error, not a no-op.',
+    inputSchema: {
+        mint: z.string(),
+        amount: z.number().int().positive().optional(),
+    },
+    annotations: { title: 'DFM asset withdraw', readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+}, async ({ mint, amount }) => {
+    const gate = writeGate();
+    if (!gate.ok)
+        return gate.result;
+    try {
+        return text(await api.withdrawAppWalletAsset(mint, amount));
+    }
+    catch (e) {
+        return errText(`withdraw_asset failed: ${e.message}`);
+    }
+});
 server.registerTool('app_wallet_rearm', {
     title: 'Re-arm the app wallet (NEW address)',
     description: '⚠️ REAL CONTROL (gated, explicit-human-only). Supersede the current app-wallet ' +
@@ -1155,23 +1023,7 @@ server.registerTool('init_rebalancer', {
     const gate = writeGate();
     if (!gate.ok)
         return gate.result;
-    try {
-        // The server-side path existed end to end — `OPERATING_TOOL_KINDS`,
-        // `TOOL_TO_OPERATING_OP`, and a `dispatch` that calls
-        // `prepareInitRebalancer` with the operating wallet — and only the MCP's
-        // refusal stood in front of it. It never belonged there: this creates the
-        // vault's RebalancerConfig and pays its rent; it transfers no admin and
-        // moves no funds between wallets.
-        const viaWallet = await keylessWrite('init_rebalancer', { vault });
-        if (viaWallet)
-            return viaWallet;
-        const res = await runInitRebalancer(config, api, vault);
-        return text(res);
-    }
-    catch (e) {
-        return errText(`init_rebalancer failed: ${e.message}` +
-            (isKeylessMode(config) ? `\n${KEYLESS_SETUP_HINT}` : ''));
-    }
+    return keylessWrite('init_rebalancer', { vault });
 });
 // ─── WRITE TOOL: rebalance_to_targets (#57 — converge to config targets) ──────
 // CONFIG IS THE SINGLE SOURCE OF TRUTH. The free-form `rebalance {in,out,amount}`
@@ -1182,7 +1034,14 @@ server.registerTool('init_rebalancer', {
 // `/execute/prepare`, just off the agent surface.)
 server.registerTool('rebalance_to_targets', {
     title: 'Rebalance a vault to its configured target weights',
-    description: 'REAL-MONEY (gated). MANAGER action — only works on a vault the test wallet ' +
+    description: 'THE MANAGER\'S RECURRING DUTY, not a convenience: a DTF\'s config is the promise, its holdings are the ' +
+        'reality, and prices pull them apart every day. A drifted fund no longer holds what its depositors bought, ' +
+        'and share price settles on-chain from the ACTUAL basket, so every new deposit mints against the drift. ' +
+        'DFM has NO automatic rebalancing (manual by design, #35) — nothing converges by itself, so an agent that ' +
+        'reads a managed vault and stays quiet about drift IS the failure. Report it with the number even when ' +
+        'nobody asked, then let the ' +
+        'manager decide; never fire this unasked. ' +
+        'REAL-MONEY (gated). MANAGER action — only works on a vault the test wallet ' +
         'ADMINS whose rebalancer is initialized (bundled into launch_vault, or run ' +
         'init_rebalancer first). CONVERGES the vault\'s live holdings toward its ' +
         'CURRENT on-chain CONFIG target weights — you supply NO inputMint/outputMint/' +
@@ -1206,21 +1065,7 @@ async ({ vault, slippageBps }) => {
     const gate = writeGate();
     if (!gate.ok)
         return gate.result;
-    try {
-        // KEYLESS: the server signs every converge leg with the operating wallet
-        // (orchestrateRebalance — ordered, 5s cooldown between legs). This is not
-        // merely a convenience here: a vault LAUNCHED through the operating wallet
-        // has that wallet as its on-chain `vault_admin`, so no locally-held key
-        // could rebalance it at all.
-        const keyless = await keylessWrite('rebalance_to_targets', { vault, slippageBps });
-        if (keyless)
-            return keyless;
-        const res = await runRebalanceToTargets(config, api, vault, slippageBps);
-        return text(res);
-    }
-    catch (e) {
-        return errText(`rebalance_to_targets failed: ${e.message}`);
-    }
+    return keylessWrite('rebalance_to_targets', { vault, slippageBps });
 });
 // ─── Start ────────────────────────────────────────────────────────────────
 /**