@needmoretruth/nmts-cli 0.17.2 → 0.34.2

package/dist/mcp-ask.js

@@ -0,0 +1,100 @@
+// Asking the PERSON a question from inside a tool call, over the protocol.
+//
+// ⛔ WHY THIS EXISTS. Every other agreement this tool takes is once per machine, written down, and
+//    then never asked about again — which is right for a capability, and wrong for an act that
+//    cannot be undone and names somebody else each time. Handing a file to another account is the
+//    one thing here where the question is not "may this tool ever do that" but "is THIS the person
+//    you meant". A recorded agreement cannot answer that, because the answer is different for
+//    every call.
+//
+// ⛔ THE CHANNEL IS `elicitation/create`, AND IT IS THE ONLY ONE THERE IS. On this server stdout is
+//    the protocol wire and stderr may be shown to nobody, so a prompt printed anywhere is a prompt
+//    the person never sees. Elicitation is a request the SERVER sends to the CLIENT — the reverse
+//    of everything else here — and the client is the half with a screen.
+//
+// ⛔ A CLIENT THAT CANNOT BE ASKED IS NOT A CLIENT THAT AGREED. Elicitation arrived in protocol
+//    version 2025-06-18 and a client declares it or does not. When it does not, this returns
+//    `unreachable` and the caller REFUSES. Falling back to the recorded once-per-machine agreement
+//    would mean the weakest client silently sets the rule for all of them, which is how a
+//    protection becomes decorative.
+//
+// ⚠ WHAT THIS IS NOT. It is not proof a person answered. The client decides what to put on screen
+//   and what to send back, and a client that answers by itself is indistinguishable from one that
+//   asked. What this buys is that the decision is put where a person can see it, once per share,
+//   in the words below — not that it cannot be automated.
+//
+// ⛔ NOTHING SENSITIVE GOES IN THE QUESTION. The specification says a server must not use
+//    elicitation to request sensitive information, and this asks for nothing at all: the schema is
+//    one boolean, and the NMTS key, the file's key and the recipient's key appear nowhere in
+//    it. The recipient's public code is in the message because it is the thing being confirmed and
+//    the model already has it.
+/**
+ * The question this server asks, in one place so that every caller asks it the same way.
+ *
+ * ⛔ ONE BOOLEAN, NOT A FREE-TEXT FIELD. A client renders this schema into whatever it renders it
+ *    into, and a checkbox somebody has to tick is the shape that survives every rendering. A text
+ *    field would let a client accept "no" as a filled-in answer.
+ */
+export const CONFIRM_SCHEMA = {
+    type: "object",
+    properties: {
+        confirm: {
+            type: "boolean",
+            title: "Yes, share it",
+            description: "Leave this off to refuse. Refusing stops the share and nothing else.",
+            default: false,
+        },
+    },
+    required: ["confirm"],
+};
+/**
+ * Read an `elicitation/create` result. Pure, so the three actions can be tested without a pipe.
+ *
+ * ⛔ ONLY `accept` WITH `confirm === true` IS A YES. `decline` and `cancel` are both no — the
+ *    specification distinguishes "refused" from "dismissed" so that a server can offer something
+ *    else, and here there is nothing else to offer. An `accept` carrying no content, or content
+ *    with the box unticked, is a no as well: the person was shown the question and did not agree.
+ *
+ * ⛔ ANYTHING UNRECOGNISED IS A NO. A malformed answer is not an answer, and the direction to fail
+ *    in is the one where a file is not handed to somebody.
+ */
+export function readAnswer(result) {
+    if (typeof result !== "object" || result === null)
+        return "no";
+    const action = Reflect.get(result, "action");
+    if (action !== "accept")
+        return "no";
+    const content = Reflect.get(result, "content");
+    if (typeof content !== "object" || content === null)
+        return "no";
+    return Reflect.get(content, "confirm") === true ? "yes" : "no";
+}
+/** Whether the client said, at `initialize`, that it can put a question in front of a person. */
+export function declaredElicitation(capabilities) {
+    if (typeof capabilities !== "object" || capabilities === null)
+        return false;
+    const value = Reflect.get(capabilities, "elicitation");
+    return typeof value === "object" && value !== null;
+}
+/**
+ * Build the asker for a session.
+ *
+ * ⛔ THE CAPABILITY IS READ ONCE, FROM `initialize`, AND NEVER GUESSED AFTERWARDS. A client that
+ *    did not declare elicitation is not sent one: the specification says a server may only use a
+ *    capability the other side declared, and a request it does not understand is at best an error
+ *    on the wire and at worst a hung tool call waiting for an answer that is never coming.
+ */
+export function askerFor(capabilities, send) {
+    if (!declaredElicitation(capabilities))
+        return null;
+    return async (message) => {
+        // ⚠ A client that declared the capability and then fails to answer must not hang the tool.
+        //   Whatever went wrong, nobody agreed, so it is a no.
+        try {
+            return readAnswer(await send("elicitation/create", { message, requestedSchema: CONFIRM_SCHEMA }));
+        }
+        catch {
+            return "no";
+        }
+    };
+}

package/dist/mcp-tools/context.d.ts

@@ -0,0 +1,46 @@
+import type { Asker } from "../mcp-ask.ts";
+import type { ToolDefinition } from "../mcp.ts";
+export interface ToolContext {
+    server: string;
+    network: string;
+    /** Where anything fetched lands. Chosen by the person, never by the model. */
+    outDir: string;
+    accountId: string;
+    /**
+     * How to put a question in front of the person, or `null` when this client declared no way.
+     *
+     * ⛔ A FUNCTION, NOT A VALUE. The tools are built when the server starts and the answer is not
+     *    known until the client has spoken, so reading it early would freeze in a `null` that was
+     *    only ever "not yet".
+     */
+    asker: () => Asker;
+}
+/** The server and network every command takes, in the shape they take it. */
+export declare function common(ctx: ToolContext): {
+    server: string;
+    network: string;
+};
+/**
+ * Collect what a command would have printed, so it can be handed to a model instead.
+ *
+ * ⛔ EVERY TOOL USES THIS AND NONE OF THEM PRINT. On this server stdout is the protocol wire; a
+ *    stray line there is a parse error at the client and the whole tool list disappears with no
+ *    explanation. Commands write through an injected sink precisely so that this can be true.
+ */
+export declare function collector(): {
+    lines: string[];
+    write: (line: string) => void;
+};
+/**
+ * Run one command with its output collected, and hand back what it wrote.
+ *
+ * ⚠ A non-zero exit code is NOT turned into a throw. A command that returns 4 has already written
+ *   the explanation the model needs, and replacing it with a generic failure would throw that
+ *   away. The commands that genuinely cannot proceed throw, and the transport reports those.
+ */
+export declare function say(run: (write: (line: string) => void) => Promise<number>): Promise<string>;
+/** A required string argument, with the same refusal every tool gives for it. */
+export declare function needString(args: Record<string, unknown>, name: string): string;
+/** Several paths at once, as the multi-path commands take them. */
+export declare function needPaths(args: Record<string, unknown>): string[];
+export type ToolFactory = (ctx: ToolContext) => ToolDefinition[];

package/dist/mcp-tools/credits.d.ts

@@ -0,0 +1,3 @@
+import type { ToolDefinition } from "../mcp.ts";
+import { type ToolContext } from "./context.ts";
+export declare function creditTools(ctx: ToolContext): ToolDefinition[];

package/dist/mcp-tools/credits.js

@@ -0,0 +1,61 @@
+// Moving credits between two accounts of one person's own family — the account they made, and
+// every account made under it.
+//
+// ⛔ IT CANNOT REACH ANYONE ELSE, and the description says so before the first call. The server
+//    refuses a recipient outside the family and answers an account that does not exist in exactly
+//    the same words, so this tool cannot be used to find out which identifiers are real — and a
+//    model that read the refusal as "wrong identifier, try another" would be walking the account
+//    space one guess at a time.
+//
+// ⛔ IT IS REVERSIBLE AND THAT IS WHY IT IS MEDIUM RATHER THAN HIGH. Nothing is spent, nothing
+//    leaves the person's own accounts, and the same call the other way puts it back. What it is
+//    NOT is `low`: it moves value, and the person should know it happened.
+//
+// ⚠ IT NEEDS THE ACCOUNT'S HUMAN CHECK TO BE LIVE, the same as the free trial. The command asks
+//   about that first and the refusal names `nmts verify`, which is a person's act — so a model
+//   that meets it must hand it to somebody rather than retry.
+import { credits } from "../commands/credits.js";
+import { common, needString, say } from "./context.js";
+export function creditTools(ctx) {
+    return [
+        {
+            name: "nmts_credits_transfer",
+            description: "Move credits from this account to another account of the SAME FAMILY — the account a " +
+                "person made and every account made under it — and nowhere else. Use it when the free " +
+                "trial's credits landed on one account and the work is happening in another: the whole " +
+                "family gets one application a week, not one each. The credits keep the date they were " +
+                "already going to lapse on; moving them does not renew them, and nothing is spent by " +
+                "moving them. The reply carries both balances. ⛔ A recipient outside the family and an " +
+                "account that does not exist are refused in the same words — do not treat that refusal " +
+                "as an invitation to try another identifier. It also needs the account's human check to " +
+                "be live; when it is not, the refusal names `nmts verify`, which only a person can run.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    to: {
+                        type: "string",
+                        description: "The receiving account's identifier, as nmts_whoami prints it for that account. " +
+                            "It has to be an account of this family. Not a public code and not an NMTS key.",
+                    },
+                    credits: {
+                        // ⚠ NO `minimum` HERE. The transport enforces only the keywords `mcp-args.ts` knows,
+                        //   and a schema keyword nothing enforces is a promise the surface does not keep —
+                        //   so the floor is checked in `run`, where it is real.
+                        type: "integer",
+                        description: "How many whole credits to move, above zero. nmts_balance says how many there are.",
+                    },
+                },
+                required: ["to", "credits"],
+                additionalProperties: false,
+            },
+            run: (args) => {
+                const to = needString(args, "to");
+                const amount = args["credits"];
+                if (typeof amount !== "number" || !Number.isSafeInteger(amount) || amount < 1) {
+                    throw new Error("`credits` must be a whole number of credits above zero.");
+                }
+                return say((write) => credits("transfer", String(amount), { ...common(ctx), to, json: true, write }));
+            },
+        },
+    ];
+}

package/dist/mcp-tools/files.d.ts

@@ -0,0 +1,3 @@
+import type { ToolDefinition } from "../mcp.ts";
+import { type ToolContext } from "./context.ts";
+export declare function fileTools(ctx: ToolContext): ToolDefinition[];

package/dist/mcp-tools/files.js

@@ -10,19 +10,49 @@
 //    this disk. `nmts_get` keeps only the last segment of the account path; `nmts_pull` builds its
 //    tree under that directory and refuses a stored name that would climb out; `nmts_receive` uses
 //    the sender's name the same way. The only path a model may choose is one INSIDE the account.
+//
+// ⛔ AND ONE THAT CHANGES SOMETHING WITHOUT SPENDING ANYTHING IS HERE RATHER THAN IN `reads.ts`.
+//    `nmts_loss_recheck` asks the chain about one storage object now, and a chain that serves it
+//    takes the line off server-side — so it writes. `reads.ts` states that none of its tools
+//    write, and that sentence is what makes the whole read surface safe to call in a loop; a tool
+//    that quietly broke it would cost the other six their guarantee. It is listed first because a
+//    model scanning this file should meet the costless one before the two that spend.
 import { get } from "../commands/get.js";
+import { losses } from "../commands/losses.js";
 import { pull } from "../commands/pull.js";
 import { push } from "../commands/push.js";
 import { put } from "../commands/put.js";
 import { receive } from "../commands/receive.js";
+import { DEPOSIT_CREDITS_MAX } from "../deposit.js";
 import { destinationFor } from "../safe-path.js";
 import { common, needString, say } from "./context.js";
 const SPENDS = "⛔ THIS SPENDS THE ACCOUNT'S CREDITS — one credit per started mebibyte, per lease period, and " +
     "credits are not refundable. Pass dry_run to be told the price without spending it. The first " +
     "upload on a machine stops and asks the person to agree; show them what it says rather than " +
     "agreeing for them.";
+const DEPOSIT_HINT = `Credits each uploaded file sets aside as a deposit, 0 to ${DEPOSIT_CREDITS_MAX}. Leave it out to use ` +
+    "the account's own default (nmts_deposit reads it). The deposit pays the chain fee of a later " +
+    "operation on that file and comes back when its storage period ends; 0 means a later release " +
+    "costs twice that fee out of the balance instead.";
 export function fileTools(ctx) {
     return [
+        {
+            name: "nmts_loss_recheck",
+            description: "Ask the chain right now about one storage object listed by nmts_losses. Costs nothing. " +
+                "Answers found, still missing, or unread.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    blob_object_id: {
+                        type: "string",
+                        description: "The chain object id, exactly as nmts_losses printed it.",
+                    },
+                },
+                required: ["blob_object_id"],
+                additionalProperties: false,
+            },
+            run: (args) => say((write) => losses({ ...common(ctx), json: true, recheck: needString(args, "blob_object_id"), write })),
+        },
         {
             name: "nmts_get",
             description: `Fetch one file from the NMTS account, decrypt it, and write it into ${ctx.outDir}. Takes ` +
@@ -86,6 +116,7 @@ export function fileTools(ctx) {
                     file: { type: "string", description: "Path to a file ON THIS MACHINE to upload." },
                     name: { type: "string", description: "The name it gets in the account. Defaults to the file's own." },
                     to: { type: "string", description: "An existing folder in the account, as nmts_list prints it." },
+                    deposit_credits: { type: "integer", description: DEPOSIT_HINT },
                     dry_run: { type: "boolean", description: "Say what it would cost and stop. Nothing is sent or charged." },
                 },
                 required: ["file"],
@@ -96,6 +127,7 @@ export function fileTools(ctx) {
                 json: true,
                 ...(typeof args["name"] === "string" ? { name: args["name"] } : {}),
                 ...(typeof args["to"] === "string" ? { to: args["to"] } : {}),
+                ...(typeof args["deposit_credits"] === "number" ? { deposit: args["deposit_credits"] } : {}),
                 ...(args["dry_run"] === true ? { dryRun: true } : {}),
                 write,
             })),
@@ -115,6 +147,7 @@ export function fileTools(ctx) {
                     directory: { type: "string", description: "Path to a directory ON THIS MACHINE." },
                     to: { type: "string", description: "An existing folder in the account to put it under." },
                     include_hidden: { type: "boolean", description: "Also send names beginning with a dot." },
+                    deposit_credits: { type: "integer", description: DEPOSIT_HINT },
                     dry_run: { type: "boolean", description: "Price the whole tree and stop. Nothing is sent or charged." },
                 },
                 required: ["directory"],
@@ -125,6 +158,7 @@ export function fileTools(ctx) {
                 json: true,
                 ...(typeof args["to"] === "string" ? { to: args["to"] } : {}),
                 ...(args["include_hidden"] === true ? { hidden: true } : {}),
+                ...(typeof args["deposit_credits"] === "number" ? { deposit: args["deposit_credits"] } : {}),
                 ...(args["dry_run"] === true ? { dryRun: true } : {}),
                 write,
             })),

package/dist/mcp-tools/organise.d.ts

@@ -0,0 +1,3 @@
+import type { ToolDefinition } from "../mcp.ts";
+import { type ToolContext } from "./context.ts";
+export declare function organiseTools(ctx: ToolContext): ToolDefinition[];

package/dist/mcp-tools/organise.js

@@ -1,7 +1,7 @@
 // Rearranging what the account holds, without moving a byte or spending anything.
 //
 // ⛔ EVERYTHING HERE IS AN EDIT TO THE SEALED LIST AND NOTHING HERE IS PERMANENT. Names, folders
-//    and marks live only inside the list the account code opens; the server never sees them and no
+//    and marks live only inside the list the NMTS key opens; the server never sees them and no
 //    stored bytes move. That is why these are the tools a model may use freely: the worst outcome
 //    is a tidy-up somebody has to undo, and every one of them has an undo.
 //
@@ -12,9 +12,12 @@
 // ⛔ SIX MARK VERBS ARE ONE TOOL, NOT SIX. A model choosing between `nmts_star` and `nmts_unstar`
 //    is choosing between two spellings of the same decision, and the pair that gets forgotten is
 //    the "un" one. One tool with the mark named and a switch says what is actually being decided.
-import { label, pin, star, unlabel, unpin, unstar } from "../commands/marks.js";
+import { deposit } from "../commands/deposit.js";
+import { label, labelRename, pin, star, unlabel, unlabelAll, unpin, unstar } from "../commands/marks.js";
 import { mkdir, mv, rename } from "../commands/organise.js";
+import { padding } from "../commands/padding.js";
 import { restore, rm } from "../commands/trash.js";
+import { DEPOSIT_CREDITS_MAX } from "../deposit.js";
 import { common, needPaths, needString, say } from "./context.js";
 export function organiseTools(ctx) {
     return [
@@ -99,6 +102,83 @@ export function organiseTools(ctx) {
                 });
             },
         },
+        {
+            name: "nmts_label_rename",
+            description: "Rename a label on every file that carries it. Changes only the file list; costs nothing.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    old: { type: "string", description: "The label as it is now." },
+                    new: { type: "string", description: "What it should be called instead." },
+                },
+                required: ["old", "new"],
+                additionalProperties: false,
+            },
+            run: (args) => say((write) => labelRename(needString(args, "old"), needString(args, "new"), {
+                ...common(ctx),
+                json: true,
+                write,
+            })),
+        },
+        {
+            name: "nmts_unlabel_all",
+            description: "Take one label off every file that carries it. Changes only the file list; costs nothing.",
+            inputSchema: {
+                type: "object",
+                properties: { name: { type: "string", description: "The label to take off." } },
+                required: ["name"],
+                additionalProperties: false,
+            },
+            run: (args) => say((write) => unlabelAll(needString(args, "name"), { ...common(ctx), json: true, write })),
+        },
+        {
+            name: "nmts_padding",
+            description: "Read or set how file sizes are hidden on the storage network: standard (a few fixed " +
+                "sizes per doubling), pow2 (one per doubling, hides more, costs more storage on " +
+                "average), or off (no padding — the file's exact length is visible to the network and " +
+                "to anyone who reads the blob, and about 1 % less storage is used). Applies to the next " +
+                "uploads from every device.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    mode: {
+                        type: "string",
+                        enum: ["standard", "pow2", "off"],
+                        description: "Leave it out to read the setting rather than change it.",
+                    },
+                },
+                additionalProperties: false,
+            },
+            run: (args) => say((write) => padding(typeof args["mode"] === "string" ? args["mode"] : undefined, {
+                ...common(ctx),
+                json: true,
+                write,
+            })),
+        },
+        {
+            name: "nmts_deposit",
+            description: "Read or set how many credits this account sets aside as a deposit on each credit-paid " +
+                `upload, 0 to ${DEPOSIT_CREDITS_MAX}. Nothing here spends: it records what the next uploads will ` +
+                "set aside, from every device. The deposit pays the chain fee of a later operation on " +
+                "that file, measured rather than spent whole, and what is left comes back when the " +
+                "storage period ends. 0 is a real answer — a file with no deposit still releases, but " +
+                "pays twice the same fee out of the balance at that moment.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    credits: {
+                        type: "integer",
+                        description: `0 to ${DEPOSIT_CREDITS_MAX}. Leave it out to read the setting rather than change it.`,
+                    },
+                },
+                additionalProperties: false,
+            },
+            run: (args) => say((write) => deposit(typeof args["credits"] === "number" ? String(args["credits"]) : undefined, {
+                ...common(ctx),
+                json: true,
+                write,
+            })),
+        },
         {
             name: "nmts_trash",
             description: "Put files in the NMTS account's trash. Nothing is destroyed and nothing is refunded: the " +

package/dist/mcp-tools/reads.d.ts

@@ -0,0 +1,3 @@
+import type { ToolDefinition } from "../mcp.ts";
+import { type ToolContext } from "./context.ts";
+export declare function readTools(ctx: ToolContext): ToolDefinition[];

package/dist/mcp-tools/reads.js

@@ -6,11 +6,17 @@
 //    the opposite of the habit this tool wants.
 import { publicCode } from "../commands/public-code.js";
 import { balance } from "../commands/balance.js";
+import { devices } from "../commands/devices.js";
+import { legal, notices } from "../commands/documents.js";
 import { expiring } from "../commands/expiring.js";
+import { losses } from "../commands/losses.js";
 import { ls } from "../commands/ls.js";
 import { shares } from "../commands/share.js";
+import { sharesSent } from "../commands/shares-sent.js";
 import { usage } from "../commands/usage.js";
-import { common, say } from "./context.js";
+import { walletActivity } from "../commands/wallet-activity.js";
+import { walletStorage } from "../commands/wallet-storage.js";
+import { common, needString, say } from "./context.js";
 const NO_ARGS = { type: "object", properties: {}, additionalProperties: false };
 export function readTools(ctx) {
     return [
@@ -59,21 +65,59 @@ export function readTools(ctx) {
             inputSchema: NO_ARGS,
             run: () => say((write) => expiring({ ...common(ctx), json: true, write })),
         },
+        {
+            name: "nmts_losses",
+            description: "Storage objects paid with this account's credits that NMTS's daily check could not find " +
+                "on the chain, newest first. Read-only; costs nothing. Each row is a public chain object " +
+                "id and the day a check first missed it — no file name, because the server cannot pair " +
+                "them.",
+            inputSchema: NO_ARGS,
+            run: () => say((write) => losses({ ...common(ctx), json: true, write })),
+        },
         {
             name: "nmts_balance",
             description: "How many credits this account has left, what that buys, and the ceilings on spending. " +
                 "Read this before uploading anything large: the price of an upload is printed, but only " +
-                "this says whether the account can pay it.",
+                "this says whether the account can pay it. `ai_account` is true when the account was made " +
+                "under somebody else's for an AI to work in, so it is not that person's own account.",
             inputSchema: NO_ARGS,
             run: () => say((write) => balance({ ...common(ctx), json: true, write })),
         },
+        {
+            name: "nmts_wallet_activity",
+            description: "The recent transactions of the wallet this account derives (newest first, 20 at most), " +
+                "each named only where the chain proves it — seal, extend, erase, exchange, send, receive, " +
+                "otherwise 'other' — with its balance changes and an explorer link. Read-only. Gifts to the " +
+                "developer appear as sends here; this tool does not know that address.",
+            inputSchema: NO_ARGS,
+            run: () => say((write) => walletActivity({ ...common(ctx), json: true, write })),
+        },
+        {
+            name: "nmts_wallet_storage",
+            description: "The storage resources (size × time on the storage network) this wallet holds unbound — " +
+                "what deleting a file from the network gave back — with whether each is usable now. " +
+                "Read-only; nothing here spends or signs.",
+            inputSchema: NO_ARGS,
+            run: () => say((write) => walletStorage({ ...common(ctx), json: true, write })),
+        },
+        {
+            name: "nmts_devices",
+            description: "What is signed in to this NMTS account: for each device, when it was first signed in, " +
+                "when it was last used, and when it runs out. ⛔ READ-ONLY. Signing a device out is a " +
+                "person's act at nmts.me and no API key can do it — including this one — so if a row " +
+                "looks wrong, say so and let the person end it rather than looking for a way to do it " +
+                "here. ⚠ The name each device was given is encrypted with the NMTS key, which the " +
+                "server has never had, so no name is returned.",
+            inputSchema: NO_ARGS,
+            run: () => say((write) => devices({ server: ctx.server, json: true, write })),
+        },
         {
             name: "nmts_public_code",
             description: "The account's PUBLIC CODE — the value other accounts send files to — and whether it has " +
                 "been published yet. Until it is published nobody can send to this account. ⛔ It only " +
                 "reads. Publishing is permanent and is a person's decision at the command line: if the " +
-                "reply says it is not published, say so rather than working around it. ⚠ Not the account " +
-                "code, which opens every file and is never given away.",
+                "reply says it is not published, say so rather than working around it. ⚠ Not the NMTS " +
+                "key, which opens every file and is never given away.",
             inputSchema: NO_ARGS,
             run: () => say((write) => publicCode({ ...common(ctx), json: true, write })),
         },
@@ -85,5 +129,89 @@ export function readTools(ctx) {
             inputSchema: NO_ARGS,
             run: () => say((write) => shares({ ...common(ctx), json: true, write })),
         },
+        {
+            name: "nmts_shares_sent",
+            description: "Who one file in the account was shared with: recipient address, since when, and the " +
+                "share id. Read-only; costs nothing.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "The file, as nmts_list prints it." },
+                },
+                required: ["path"],
+                additionalProperties: false,
+            },
+            run: (args) => say((write) => sharesSent(needString(args, "path"), { ...common(ctx), json: true, write })),
+        },
+        // ── The documents this service publishes ──────────────────────────────────────────────────
+        //
+        // ⛔ THEY ARE HERE BECAUSE AN AGENT IS OFTEN THE ONLY READER. An account driven from a program
+        //    is still governed by the Terms, and is still owed the seven days' warning a notice gives
+        //    before a new version takes effect. A surface that could upload but could not read the
+        //    notice saying uploads stop on Tuesday is a surface that keeps somebody uninformed.
+        //
+        // ⛔ NONE OF THEM SAVES A FILE. Keeping a dated copy is `nmts notices --save`, at a command
+        //    line, where a person chose the directory — the rule this whole surface is built on.
+        {
+            name: "nmts_notices",
+            description: "The NMTS notice board as JSON, newest first: interruptions, incidents, and the notice " +
+                "given before a new version of the Terms takes effect. Ids here are what nmts_notice " +
+                "takes. Public and read-only; it costs nothing and needs no account.",
+            inputSchema: NO_ARGS,
+            run: () => say((write) => notices({ ...common(ctx), json: true, write })),
+        },
+        {
+            name: "nmts_notice",
+            description: "One notice in full, as the dated text the board's download button writes — the same " +
+                "bytes. Read this before acting on anything nmts_notices only summarised.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    id: { type: "string", description: "The notice, as nmts_notices lists it." },
+                },
+                required: ["id"],
+                additionalProperties: false,
+            },
+            run: (args) => say((write) => notices({ ...common(ctx), id: needString(args, "id"), write })),
+        },
+        {
+            name: "nmts_terms",
+            description: "The NMTS Terms of Service in force, as text, with its version and effective date at the " +
+                "head. ⛔ Reading them is not accepting them: nothing here or anywhere in this tool can " +
+                "agree to a document on somebody's behalf, and the server refuses until a person does it " +
+                "at nmts.me.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    lang: { type: "string", enum: ["en", "ko"], description: "Absent means English, the canonical text." },
+                    board: { type: "boolean", description: "The message board's terms rather than the service's." },
+                },
+                additionalProperties: false,
+            },
+            run: (args) => say((write) => legal("terms", {
+                ...common(ctx),
+                ...(typeof args["lang"] === "string" ? { lang: args["lang"] } : {}),
+                ...(args["board"] === true ? { board: true } : {}),
+                write,
+            })),
+        },
+        {
+            name: "nmts_privacy",
+            description: "The NMTS Privacy Policy in force, as text, with its version and effective date at the " +
+                "head. It is what the service says it collects and keeps; read it rather than describing " +
+                "it from memory.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    lang: { type: "string", enum: ["en", "ko"], description: "Absent means English, the canonical text." },
+                },
+                additionalProperties: false,
+            },
+            run: (args) => say((write) => legal("privacy", {
+                ...common(ctx),
+                ...(typeof args["lang"] === "string" ? { lang: args["lang"] } : {}),
+                write,
+            })),
+        },
     ];
 }

package/dist/mcp-tools/share.d.ts

@@ -0,0 +1,3 @@
+import type { ToolDefinition } from "../mcp.ts";
+import { type ToolContext } from "./context.ts";
+export declare function shareTools(ctx: ToolContext): ToolDefinition[];