@dfm-fi/agent 0.2.1881 → 0.2.1896

package/dist/api-client.d.ts

@@ -1,5 +1,23 @@
 import type { AgentConfig } from './config.js';
 import { SiwsSession } from './session.js';
+import type { SignerRequest } from './app-wallet-owner.js';
+/** Response of the headless app-wallet routes (see api agent-app-wallet.controller.ts). */
+export type AgentAppWalletStep = {
+    status: 'active';
+    created: boolean;
+    appWallet: {
+        operatingWalletAddress?: string;
+        status?: string;
+    } & Record<string, unknown>;
+} | {
+    status: 'awaiting_owner_signature';
+    reason?: 'create' | 'policy_update';
+    walletId: string;
+    address: string;
+    signerId: string;
+    policyId: string;
+    request: SignerRequest;
+};
 import type { VaultListResponse, VaultDetailResponse, ZapV2Status, ZapV2PrepareResponse, ZapV2SingleTxResponse, CreateAssetInput, CreatePrepareResponse, CreateConfirmResponse, RebalanceToTargetsResponse, ReconfigureResponse, ReconfigureTargetInput, OnchainPolicySnapshot, VaultPolicyInput } from './types.js';
 export declare class DfmApiClient {
     private readonly session;
@@ -77,7 +95,16 @@ export declare class DfmApiClient {
         wallet?: string;
         operatingWalletAddress?: string;
         status?: string;
+        policyUpdateRequired?: boolean;
     } | null>;
+    /**
+     * `POST /agent/operating/embedded/agent-wallet` — step 1 of headless app-wallet
+     * creation: send ONLY the owner's P-256 public key. Session-only server-side,
+     * so this always signs in with SIWS (a local keypair), never with DFM_API_KEY.
+     */
+    beginAgentAppWallet(ownerPublicKey: string): Promise<AgentAppWalletStep>;
+    /** Step 2: relay the owner's signature over the exact signer request step 1 returned. */
+    confirmAgentAppWallet(ownerPublicKey: string, signature: string): Promise<AgentAppWalletStep>;
     /** `GET /profile` — human label for the authenticated identity. */
     /** Public profile of any trader, by wallet or username (social parity, 2026-10-09). */
     getTraderProfile(by: {

package/dist/api-client.js

@@ -43,7 +43,7 @@ export class DfmApiClient {
         // The API requires an X-Idempotency-Key on every mutating request. Generate
         // ONE key per logical call and reuse it across the transparent 401 re-auth
         // retry below, so a retry is treated as the same operation (never doubled).
-        const { idempotencyKey: pinnedKey, ...reqInit } = init ?? {};
+        const { idempotencyKey: pinnedKey, sessionOnly, ...reqInit } = init ?? {};
         const method = (reqInit.method ?? 'GET').toUpperCase();
         const mutating = method !== 'GET' && method !== 'HEAD';
         const idempotencyKey = mutating ? (pinnedKey ?? randomUUID()) : undefined;
@@ -60,7 +60,7 @@ export class DfmApiClient {
         // key is revocable and capped (read-only unless explicitly widened).
         // There is no re-auth loop here — a key does not expire; a 401 means it was
         // revoked, and silently retrying a revoked credential would be wrong.
-        const apiKey = process.env.DFM_API_KEY?.trim();
+        const apiKey = sessionOnly ? undefined : process.env.DFM_API_KEY?.trim();
         if (apiKey) {
             const res = await fetch(`${this.baseUrl}${path}`, {
                 ...reqInit,
@@ -203,6 +203,26 @@ export class DfmApiClient {
     async getOperatingWallet() {
         return this.authRequest('/agent/operating', { method: 'GET' });
     }
+    /**
+     * `POST /agent/operating/embedded/agent-wallet` — step 1 of headless app-wallet
+     * creation: send ONLY the owner's P-256 public key. Session-only server-side,
+     * so this always signs in with SIWS (a local keypair), never with DFM_API_KEY.
+     */
+    async beginAgentAppWallet(ownerPublicKey) {
+        return this.authRequest('/agent/operating/embedded/agent-wallet', {
+            method: 'POST',
+            body: JSON.stringify({ ownerPublicKey }),
+            sessionOnly: true,
+        });
+    }
+    /** Step 2: relay the owner's signature over the exact signer request step 1 returned. */
+    async confirmAgentAppWallet(ownerPublicKey, signature) {
+        return this.authRequest('/agent/operating/embedded/agent-wallet/confirm', {
+            method: 'POST',
+            body: JSON.stringify({ ownerPublicKey, signature }),
+            sessionOnly: true,
+        });
+    }
     /** `GET /profile` — human label for the authenticated identity. */
     /** Public profile of any trader, by wallet or username (social parity, 2026-10-09). */
     async getTraderProfile(by) {

package/dist/app-wallet-owner.d.ts

@@ -0,0 +1,83 @@
+export declare const DEFAULT_OWNER_KEY_DIR: string;
+export declare const DEFAULT_OWNER_KEY_PATH: string;
+/** DFM's Privy signer key quorum (the production `PRIVY_EMBEDDED_SIGNER_QUORUM_ID`). */
+export declare const DFM_PRIVY_SIGNER_QUORUM_ID = "elhpm1tlfxhqimb397m9opg8";
+/** DFM's Privy app id — public: it ships in the web bundle (`VITE_PRIVY_APP_ID`, web/src/lib/dev-proxy.ts). */
+export declare const DFM_PRIVY_APP_ID = "cmrgqda8l00yo0cl9j49ye64k";
+/** The furthest ahead a `privy-request-expiry` may be before the agent refuses to sign it. */
+export declare const MAX_REQUEST_EXPIRY_AHEAD_MS: number;
+/** The pins, overridable ONLY by the agent operator's local env (never by the server). */
+export declare function signerPins(): {
+    signerId: string;
+    appId: string;
+};
+/** Owner key path: `DFM_APP_WALLET_OWNER_KEY_PATH` or the default. Never a tool argument. */
+export declare function ownerKeyPath(): string;
+export interface OwnerKey {
+    path: string;
+    /** base64 DER SPKI — the format Privy's `owner.public_key` and key quorums use. */
+    publicKey: string;
+    created: boolean;
+    sign(payload: string): string;
+}
+/** Load the owner key at `path`, or create it (0600) when absent. */
+export declare function loadOrCreateOwnerKey(path?: string): OwnerKey;
+/** RFC 8785 (JCS) for the JSON shapes Privy signs: sorted keys, ES string/number serialization. */
+export declare function canonicalJson(v: unknown): string;
+export interface SignerRequest {
+    method: string;
+    url: string;
+    body: {
+        additional_signers: Array<{
+            signer_id: string;
+            override_policy_ids: string[];
+        }>;
+    };
+    headers: Record<string, string>;
+    payload: string;
+}
+/**
+ * Refuse anything that is not "set THIS wallet's signers to exactly [DFM's
+ * pinned quorum with exactly [policyId]]", for DFM's pinned app, expiring
+ * within 10 minutes. Returns the locally rebuilt payload to sign.
+ */
+export declare function checkSignerRequest(req: SignerRequest, expect: {
+    walletId: string;
+    policyId: string;
+}, now?: number): string;
+type Step = {
+    status: 'active';
+    created: boolean;
+    appWallet: Record<string, unknown>;
+} | {
+    status: 'awaiting_owner_signature';
+    reason?: 'create' | 'policy_update';
+    walletId: string;
+    address: string;
+    signerId: string;
+    policyId: string;
+    request: SignerRequest;
+};
+/**
+ * The whole `create_app_wallet` flow: load/create the owner key, send its
+ * PUBLIC half, check + sign the one signer request (a creation or a policy
+ * reissue), confirm. Idempotent end to end — re-running resumes the same
+ * wallet with the same key.
+ */
+export declare function runCreateAppWallet(api: {
+    beginAgentAppWallet(ownerPublicKey: string): Promise<Step>;
+    confirmAgentAppWallet(ownerPublicKey: string, signature: string): Promise<Step>;
+}, keyPath?: string): Promise<Record<string, unknown>>;
+export declare const POLICY_UPDATE_NOTICE = "DFM's signing rules changed \u2014 run create_app_wallet to approve them";
+/**
+ * The line `app_wallet` / `whoami` add when the API flags a pending policy
+ * reissue for this agent-key wallet. Signing keeps working on the old policy
+ * meanwhile (web parity), so this informs; it never blocks.
+ */
+export declare function policyUpdateNotice(op: {
+    policyUpdateRequired?: unknown;
+} | null | undefined): {
+    policyUpdate?: string;
+};
+export {};
+//# sourceMappingURL=app-wallet-owner.d.ts.map

package/dist/app-wallet-owner.js

@@ -0,0 +1,195 @@
+/**
+ * The OWNER KEY of a headless agent's app wallet (2026-10-19).
+ *
+ * An agent with no browser cannot be a Privy user, so its app wallet is owned
+ * by a P-256 key generated HERE, on the agent's machine. DFM only ever sees the
+ * public half; the private key signs exactly one kind of request: the Privy
+ * PATCH that sets DFM's policy-bound signer on the wallet.
+ *
+ * Rules this file enforces (it does NOT trust the DFM server):
+ *   • the PEM is written once, mode 0600, with `wx` (never overwrites); an
+ *     existing file is reused — rotating it would orphan the wallet. Symlinks
+ *     (file or parent dir), a file owned by another uid, or one readable by
+ *     group/others are refused, not "fixed". Only `~/.config/dfm` itself is
+ *     ever created (0700); any other missing directory is refused;
+ *   • the request is checked against values PINNED HERE, not against the
+ *     server's own answer: `signer_id` must be DFM's signer quorum and
+ *     `privy-app-id` DFM's Privy app (both overridable only by local env), the
+ *     body exactly one signer with exactly one policy, the headers exactly
+ *     {privy-app-id, privy-request-expiry} with an expiry in the next 10 min;
+ *   • the payload is rebuilt locally and must equal the server's.
+ * RESIDUAL: the policy id is trusted to DFM's server. Reading a policy's
+ * content needs Privy's app secret, which only the server has — the server
+ * re-reads it from Privy before handing the request out, the agent cannot.
+ */
+import { createPrivateKey, createPublicKey, generateKeyPairSync, sign } from 'node:crypto';
+import { lstatSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+export const DEFAULT_OWNER_KEY_DIR = join(homedir(), '.config', 'dfm');
+export const DEFAULT_OWNER_KEY_PATH = join(DEFAULT_OWNER_KEY_DIR, 'app-wallet-owner.pem');
+/** DFM's Privy signer key quorum (the production `PRIVY_EMBEDDED_SIGNER_QUORUM_ID`). */
+export const DFM_PRIVY_SIGNER_QUORUM_ID = 'elhpm1tlfxhqimb397m9opg8';
+/** DFM's Privy app id — public: it ships in the web bundle (`VITE_PRIVY_APP_ID`, web/src/lib/dev-proxy.ts). */
+export const DFM_PRIVY_APP_ID = 'cmrgqda8l00yo0cl9j49ye64k';
+/** The furthest ahead a `privy-request-expiry` may be before the agent refuses to sign it. */
+export const MAX_REQUEST_EXPIRY_AHEAD_MS = 10 * 60 * 1000;
+/** The pins, overridable ONLY by the agent operator's local env (never by the server). */
+export function signerPins() {
+    return {
+        signerId: process.env.DFM_PRIVY_SIGNER_QUORUM_ID?.trim() || DFM_PRIVY_SIGNER_QUORUM_ID,
+        appId: process.env.DFM_PRIVY_APP_ID?.trim() || DFM_PRIVY_APP_ID,
+    };
+}
+/** Owner key path: `DFM_APP_WALLET_OWNER_KEY_PATH` or the default. Never a tool argument. */
+export function ownerKeyPath() {
+    return process.env.DFM_APP_WALLET_OWNER_KEY_PATH?.trim() || DEFAULT_OWNER_KEY_PATH;
+}
+const lstatOrNull = (p) => {
+    try {
+        return lstatSync(p);
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return null;
+        throw e;
+    }
+};
+const myUid = () => (typeof process.getuid === 'function' ? process.getuid() : undefined);
+function assertSafeDir(dir) {
+    let st = lstatOrNull(dir);
+    if (!st) {
+        if (resolve(dir) !== resolve(DEFAULT_OWNER_KEY_DIR))
+            throw new Error(`${dir} does not exist — create it yourself (0700) first`);
+        mkdirSync(dir, { mode: 0o700 }); // ~/.config/dfm only, not recursive
+        st = lstatSync(dir);
+    }
+    if (st.isSymbolicLink())
+        throw new Error(`${dir} is a symlink — refusing to keep an owner key behind it`);
+    if (!st.isDirectory())
+        throw new Error(`${dir} is not a directory`);
+    const uid = myUid();
+    if (uid !== undefined && st.uid !== uid)
+        throw new Error(`${dir} is not owned by the current user`);
+    if ((st.mode & 0o022) !== 0)
+        throw new Error(`${dir} is writable by other users`);
+}
+/** Load the owner key at `path`, or create it (0600) when absent. */
+export function loadOrCreateOwnerKey(path = ownerKeyPath()) {
+    assertSafeDir(dirname(path));
+    let pem;
+    let created = false;
+    const st = lstatOrNull(path);
+    if (st) {
+        if (st.isSymbolicLink())
+            throw new Error(`${path} is a symlink — refusing to use it as the owner key`);
+        if (!st.isFile())
+            throw new Error(`${path} exists and is not a regular file`);
+        const uid = myUid();
+        if (uid !== undefined && st.uid !== uid)
+            throw new Error(`${path} is not owned by the current user`);
+        if ((st.mode & 0o077) !== 0) {
+            throw new Error(`${path} is readable by other users (mode ${(st.mode & 0o777).toString(8)}); run chmod 600 on it first`);
+        }
+        pem = readFileSync(path, 'utf8');
+    }
+    else {
+        const { privateKey } = generateKeyPairSync('ec', { namedCurve: 'prime256v1' });
+        pem = privateKey.export({ type: 'pkcs8', format: 'pem' }).toString();
+        // `wx`: fail if anything (file or symlink) appeared in between — never overwrite an owner key.
+        writeFileSync(path, pem, { mode: 0o600, flag: 'wx' });
+        created = true;
+    }
+    const priv = createPrivateKey({ key: pem, format: 'pem' });
+    if (priv.asymmetricKeyType !== 'ec' || priv.asymmetricKeyDetails?.namedCurve !== 'prime256v1') {
+        throw new Error(`${path} is not a P-256 (prime256v1) private key`);
+    }
+    const publicKey = Buffer.from(createPublicKey(priv).export({ type: 'spki', format: 'der' })).toString('base64');
+    return {
+        path,
+        publicKey,
+        created,
+        sign: (payload) => sign('sha256', Buffer.from(payload, 'utf8'), priv).toString('base64'),
+    };
+}
+/** RFC 8785 (JCS) for the JSON shapes Privy signs: sorted keys, ES string/number serialization. */
+export function canonicalJson(v) {
+    if (v === null || typeof v !== 'object')
+        return JSON.stringify(v);
+    if (Array.isArray(v))
+        return `[${v.map(canonicalJson).join(',')}]`;
+    const o = v;
+    return `{${Object.keys(o).filter((k) => o[k] !== undefined).sort()
+        .map((k) => `${JSON.stringify(k)}:${canonicalJson(o[k])}`).join(',')}}`;
+}
+const keysAre = (o, keys) => !!o && typeof o === 'object' && !Array.isArray(o) && Object.keys(o).sort().join() === [...keys].sort().join();
+/**
+ * Refuse anything that is not "set THIS wallet's signers to exactly [DFM's
+ * pinned quorum with exactly [policyId]]", for DFM's pinned app, expiring
+ * within 10 minutes. Returns the locally rebuilt payload to sign.
+ */
+export function checkSignerRequest(req, expect, now = Date.now()) {
+    const pins = signerPins();
+    const url = `https://api.privy.io/v1/wallets/${encodeURIComponent(expect.walletId)}`;
+    const s = req?.body?.additional_signers;
+    const entry = Array.isArray(s) && s.length === 1 ? s[0] : undefined;
+    const ids = entry?.override_policy_ids;
+    const expiry = req?.headers?.['privy-request-expiry'];
+    const shapeOk = keysAre(req, ['method', 'url', 'body', 'headers', 'payload']) &&
+        req.method === 'PATCH' &&
+        req.url === url &&
+        keysAre(req.body, ['additional_signers']) &&
+        keysAre(entry, ['signer_id', 'override_policy_ids']) &&
+        entry?.signer_id === pins.signerId &&
+        Array.isArray(ids) && ids.length === 1 &&
+        typeof expect.policyId === 'string' && expect.policyId.length > 0 &&
+        ids[0] === expect.policyId &&
+        keysAre(req.headers, ['privy-app-id', 'privy-request-expiry']) &&
+        req.headers['privy-app-id'] === pins.appId &&
+        typeof expiry === 'string' && /^\d{13}$/.test(expiry) &&
+        Number(expiry) > now && Number(expiry) <= now + MAX_REQUEST_EXPIRY_AHEAD_MS;
+    if (!shapeOk) {
+        throw new Error('refusing to sign: the request is not exactly "set DFM’s pinned signer with one per-wallet policy, expiring within 10 min"');
+    }
+    const payload = canonicalJson({ version: 1, method: 'PATCH', url, body: req.body, headers: req.headers });
+    if (payload !== req.payload)
+        throw new Error('refusing to sign: the server payload differs from the request it describes');
+    return payload;
+}
+/**
+ * The whole `create_app_wallet` flow: load/create the owner key, send its
+ * PUBLIC half, check + sign the one signer request (a creation or a policy
+ * reissue), confirm. Idempotent end to end — re-running resumes the same
+ * wallet with the same key.
+ */
+export async function runCreateAppWallet(api, keyPath = ownerKeyPath()) {
+    const key = loadOrCreateOwnerKey(keyPath);
+    const ownerKey = { path: key.path, publicKey: key.publicKey, createdNow: key.created };
+    let step = await api.beginAgentAppWallet(key.publicKey);
+    const signed = step.status === 'awaiting_owner_signature' ? (step.reason ?? 'create') : null;
+    if (step.status === 'awaiting_owner_signature') {
+        const payload = checkSignerRequest(step.request, step);
+        step = await api.confirmAgentAppWallet(key.publicKey, key.sign(payload));
+    }
+    if (step.status !== 'active')
+        throw new Error(`unexpected app wallet status: ${step.status}`);
+    return {
+        status: 'active',
+        created: step.created,
+        ...(signed === 'policy_update' ? { policyUpdated: true } : {}),
+        appWallet: step.appWallet,
+        ownerKey,
+        note: `The owner key at ${key.path} is the ONLY key that owns this app wallet — back it up offline. ` +
+            'DFM cannot recover it. Fund the app wallet with USDC + a little SOL, then deposit/launch as usual.',
+    };
+}
+export const POLICY_UPDATE_NOTICE = "DFM's signing rules changed — run create_app_wallet to approve them";
+/**
+ * The line `app_wallet` / `whoami` add when the API flags a pending policy
+ * reissue for this agent-key wallet. Signing keeps working on the old policy
+ * meanwhile (web parity), so this informs; it never blocks.
+ */
+export function policyUpdateNotice(op) {
+    return op?.policyUpdateRequired === true ? { policyUpdate: POLICY_UPDATE_NOTICE } : {};
+}
+//# sourceMappingURL=app-wallet-owner.js.map

package/dist/mcp-server.js

@@ -66,6 +66,7 @@ import { DfmApiClient } from './api-client.js';
 import { isKeylessMode, executeAppWalletWrite, KEYLESS_SETUP_HINT, } from './keyless.js';
 import { runAcceptAdminTransfer, runUpdateVaultPolicy, reconcileKeylessUpdateVaultPolicy, } from './manager-flow.js';
 import { submitSignedTx } from './submit.js';
+import { DEFAULT_OWNER_KEY_PATH, ownerKeyPath, policyUpdateNotice, runCreateAppWallet } from './app-wallet-owner.js';
 import { signBase64Transaction } from './signing.js';
 import { buildWalletIdentity, resolveZapStatusWallet, withActingWalletAlias, withPortfolioWalletAlias, } from './wallet-identity.js';
 const config = loadConfig();
@@ -443,6 +444,7 @@ server.registerTool('app_wallet', {
                 ? { withdrawable: { usdc, sol: bal.withdrawableSolLamports / 1_000_000_000 } }
                 : {}),
             nextStep,
+            ...policyUpdateNotice(grant),
         });
     }
     catch (e) {
@@ -507,6 +509,26 @@ server.registerTool('report_bug', {
         return errText(`report_bug failed: ${e.message}`);
     }
 });
+server.registerTool('create_app_wallet', {
+    title: 'Create my app wallet (headless)',
+    description: "Create this agent's DFM APP WALLET without a browser. Generates a P-256 owner key on THIS machine " +
+        `(${DEFAULT_OWNER_KEY_PATH} or DFM_APP_WALLET_OWNER_KEY_PATH, mode 0600; reused if it exists, never ` +
+        "overwritten), sends DFM only the public key, and signs the one Privy request that sets DFM's " +
+        'policy-bound signer (cash-out to the sign-in wallet only). The signer id and Privy app id are pinned in ' +
+        'this MCP, not taken from the server; the per-wallet POLICY id is trusted to DFM (its content can only be ' +
+        'read with Privy\'s app secret). Call it again when DFM reissues the policy. DFM never holds the key. ' +
+        'Needs a SIWS sign-in (a local keypair, DFM_AGENT_KEYPAIR_PATH) — a dfm_ API key cannot create custody. ' +
+        'Idempotent: returns the existing app wallet if there is one. Moves no funds.',
+    inputSchema: {},
+    annotations: { readOnlyHint: false, idempotentHint: true, openWorldHint: true },
+}, async () => {
+    try {
+        return text(await runCreateAppWallet(api, ownerKeyPath()));
+    }
+    catch (e) {
+        return errText(`create_app_wallet failed: ${e.message}`);
+    }
+});
 server.registerTool('xp_status', {
     title: 'XP',
     description: "The user's XP (total and by kind: deposit, launch, profile, referral) and the top of the XP leaderboard.",
@@ -529,8 +551,8 @@ server.registerTool('whoami', {
     annotations: { readOnlyHint: true, openWorldHint: true },
 }, async () => {
     try {
-        const [identity, profile] = await Promise.all([
-            resolveWalletIdentity(),
+        const [{ identity, op }, profile] = await Promise.all([
+            resolveWalletIdentityWithOp(),
             api.getProfile().catch(() => null),
         ]);
         return text({
@@ -549,6 +571,7 @@ server.registerTool('whoami', {
                     setupHint: 'No active app-wallet signer. Call app_wallet for its status and next step; ' +
                         'an external keypair cannot sign fund operations.',
                 }),
+            ...policyUpdateNotice(op),
             apiUrl: config.apiUrl,
             cluster: config.cluster,
             writeEnabled: config.writeEnabled,
@@ -673,13 +696,17 @@ function keylessUnsupported(tool) {
  * would silently keep reporting (and inspecting) a stale address.
  */
 async function resolveWalletIdentity() {
+    return (await resolveWalletIdentityWithOp()).identity;
+}
+/** Same lookup, also handing back the raw grant (whoami reads `policyUpdateRequired` off it). */
+async function resolveWalletIdentityWithOp() {
     const localSignIn = isKeylessMode(config) ? null : session.walletAddress;
     try {
         const op = await api.getOperatingWallet();
-        return buildWalletIdentity(op, localSignIn);
+        return { identity: buildWalletIdentity(op, localSignIn), op };
     }
     catch {
-        return buildWalletIdentity(null, localSignIn);
+        return { identity: buildWalletIdentity(null, localSignIn), op: null };
     }
 }
 async function keylessWrite(tool, args) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dfm-fi/agent",
-  "version": "0.2.1881",
+  "version": "0.2.1896",
   "description": "DFM v2 MCP server — drive the full fund launch → deposit → redeem (+ manage) lifecycle from an AI agent against the live API.",
   "homepage": "https://app.dfm.finance",
   "type": "module",
@@ -47,7 +47,7 @@
     "lint": "eslint .",
     "example:read": "tsx src/examples/list-and-status.ts",
     "example:lifecycle": "tsx src/examples/launch-deposit-redeem.ts",
-    "test": "npm run build && node scripts/smoke-signing.mjs && node scripts/smoke-signing-v1.mjs &&node scripts/smoke-cli.mjs && node scripts/smoke-keyless.mjs && node scripts/smoke-zap-options.mjs && tsx src/who-pays.test.ts && tsx src/wallet-identity.test.ts && tsx src/money-path.test.ts && tsx src/control-flow.test.ts && tsx src/create-flow.metadata.test.ts && tsx src/manager-flow.reconfigure.test.ts && tsx src/recovery-flow.deadleg.test.ts && tsx src/zap-v2-flow.pending.test.ts && tsx src/mcp-server.confirm-gate.test.ts"
+    "test": "npm run build && node scripts/smoke-signing.mjs && node scripts/smoke-signing-v1.mjs &&node scripts/smoke-cli.mjs && node scripts/smoke-keyless.mjs && node scripts/smoke-zap-options.mjs && tsx src/who-pays.test.ts && tsx src/wallet-identity.test.ts && tsx src/money-path.test.ts && tsx src/control-flow.test.ts && tsx src/create-flow.metadata.test.ts && tsx src/manager-flow.reconfigure.test.ts && tsx src/recovery-flow.deadleg.test.ts && tsx src/zap-v2-flow.pending.test.ts && tsx src/mcp-server.confirm-gate.test.ts && tsx src/app-wallet-owner.test.ts"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",

package/skills.md

@@ -129,11 +129,12 @@ BE PROACTIVE ABOUT THE NEXT STEP, NOT ABOUT NEW SCOPE. Finish the job the person
 
 ## Tools
 
-Kim's in-app registry exposes **39 tools** (19 READ + 20 WRITE). External agents mount the official MCP and MUST treat its runtime `listTools` result as the available subset; the two surfaces intentionally are not assumed to be identical. READ tools are free and touch no funds; WRITE tools move only the caller's own funds or administered vaults.
+Kim's in-app registry exposes **40 tools** (20 READ + 20 WRITE). External agents mount the official MCP and MUST treat its runtime `listTools` result as the available subset; the two surfaces intentionally are not assumed to be identical. READ tools are free and touch no funds; WRITE tools move only the caller's own funds or administered vaults.
 
-**READ (19)** — safe, no funds, no gate:
+**READ (20)** — safe, no funds, no gate:
 - `whoami` — The user's display name, primary DFM app wallet, separate sign-in/funding wallet, cluster, and write status. Call FIRST in a session; when an app wallet exists, do not present the sign-in wallet as their DFM wallet.
 - `app_wallet` — The user's APP WALLET (operating/sub-wallet): whether they have one, its status, its LIVE onchain SOL + USDC, and what they must do next. Call this before telling a user why an autonomous action was refused — the usual reason is no wallet, not activated, or an empty float, and each has a different fix.
+- `create_app_wallet` — Get the user's APP WALLET created. In the app it is created automatically at sign-in and approved in the browser (no key leaves the user); this returns the current app wallet state and, if there is none yet, exactly how to get it. Headless agents use the MCP tool of the same name, which creates a wallet owned by a key generated on their own machine. Moves no funds.
 - `list_app_wallet_assets` — EVERY token the app wallet holds — fund shares included — with amount, decimals, USD value and whether the mint is one of our fund shares. `app_wallet` answers USDC and SOL only (that is what the float is), so it cannot see a single share. Use this when the user asks what they hold, or before proposing a withdrawal.
 - `list_dtfs` — Browse live funds (optional category filter).
 - `get_vault` — One vault: weights, deviations, fees, TVL, NAV.