@ffschrattenecker/tm1-mcp-server 6.0.0 → 6.1.1

package/CHANGELOG.md

@@ -7,6 +7,78 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [6.1.1] - 2026-09-26
+
+### Fixed
+
+- **Publishing.** The publish workflow handed npm the tarball as `pkg/<file>.tgz`, which npm reads
+  as a GitHub `user/repo` spec, so the 6.1.0 release failed at upload. Contents are identical to
+  6.1.0, which was tagged but never reached npm: install 6.1.1.
+
+## [6.1.0] - 2026-09-26 [not published]
+
+### Added
+
+- **`tm1_delete_dimension` / `tm1_delete_cube` `dryRun`.** Returns every process and rule that
+  references the object, per source, plus the cubes a dimension is part of. Nothing is deleted,
+  and it needs no `confirm` (the field is now optional in the schema and still required on the real
+  call). Before, the check before a delete took `tm1_analyze_object_usage` plus
+  `tm1_find_orphan_dimensions` as separate calls. Elements are not covered: the usage index does
+  not resolve element references.
+- **`TM1_ENVIRONMENT=dev|test|prod`, and `mode`/`environment` in `tm1_get_server_info`.**
+  `mcpServer` now carries `mode` (`readonly`/`readwrite`), `environment` (`unspecified` when
+  unset) and, when the mode was forced, `modeReason`. Before, a client could only guess which
+  environment it was on from free-text labels, and inferred readonly from missing tools.
+  `TM1_ENVIRONMENT=prod` forces readonly even under `TM1_MODE=readwrite`, unless
+  `TM1_ALLOW_PROD_WRITES=true` is set too. A readwrite `.env` copied from a dev instance is the
+  easy way to end up with write tools on production. An unknown value refuses to start, like
+  `TM1_MODE`.
+- **`tm1_execute_process` attaches the run's error log.** When TM1 names an error log for the run
+  (a failure, or `HasMinorErrors` on a run that committed), the last 40 lines come back as
+  `errorLog`. A run that reports `CompletedWithMessages` can still have skipped every record, and
+  telling that apart used to need a `tm1_diagnose_process_error` call on every non-clean run. That
+  tool stays for cascade siblings and older logs.
+- **`tm1_set_cube_rules` and `tm1_write_cells` read back what they wrote.** `set_cube_rules`
+  returns `verified.textMatches`; `write_cells` re-reads up to 20 of the written cells and lists
+  any whose stored value differs in `verified.mismatches` (a rule or spread overriding the value).
+  Each replaces a separate read-back call. A failed read-back is reported as `readBackError` and
+  never turns a landed write into an error.
+- **`tm1_upsert_process` `dryRun`.** Runs the syntax and the reference check on the process as it
+  would be after the call, reports both (neither stops the other), and diffs it against the
+  installed version with credentials masked. Nothing is written. It needs no `confirm` and does not
+  count as one: the real overwrite still asks. Before, a caller that wanted the findings in front of
+  the user before the overwrite needed `tm1_check_process_code`, `tm1_validate_process_refs` and a
+  diff as three separate calls, because the install preflight only runs once the write is approved.
+- **`tm1_upsert_process` reads the code back.** The result carries `verified: {codeMatches,
+  mismatchedTabs}` for the tabs it sent, so confirming the change landed no longer takes a
+  `tm1_get_process_code` call.
+
+### ⚠️ Behavior change
+
+- **Node.js 22.19 or newer is required.** Node 20 reached end of life in April 2026. CI now
+  tests Node 22 and 24.
+
+### Security
+
+- **Consumers now get the pinned dependency tree.** The package ships `npm-shrinkwrap.json`, so
+  `npx` installs the exact versions CI tested and audited. Before, the lockfile was never published
+  and dependencies resolved fresh on every install, so the 6.0.1 lockfile fixes did not reach users.
+- **Hardened release pipeline.** npm publishing runs in a separate job that holds the OIDC
+  token and only uploads the tarball built and tested in the previous job.
+
+### Note
+
+- 6.0.1 was tagged but never published to npm (the tag push did not trigger the publish
+  workflow). Its fixes ship in the next release.
+
+## [6.0.1] - 2026-09-25
+
+### Security
+
+- **Dependency advisories patched.** The lockfile now pins fixed versions of `fast-uri` (host
+  confusion / SSRF, high), `hono` and `@hono/node-server`, `qs` and `body-parser` (moderate / low),
+  all pulled in by the MCP SDK. No tool contract changes.
+
 ## [6.0.0] - 2026-09-25
 
 ### Breaking
@@ -1194,7 +1266,10 @@ Initial public release.
 - Quality gates: strict typecheck, ESLint, `lint:no-flat-api`,
   annotation-coverage, and tool-registration wiring.
 
-[Unreleased]: https://github.com/ffschrattenecker/tm1-mcp-server/compare/v6.0.0...HEAD
+[Unreleased]: https://github.com/ffschrattenecker/tm1-mcp-server/compare/v6.1.1...HEAD
+[6.1.1]: https://github.com/ffschrattenecker/tm1-mcp-server/compare/v6.1.0...v6.1.1
+[6.1.0]: https://github.com/ffschrattenecker/tm1-mcp-server/compare/v6.0.1...v6.1.0
+[6.0.1]: https://github.com/ffschrattenecker/tm1-mcp-server/compare/v6.0.0...v6.0.1
 [6.0.0]: https://github.com/ffschrattenecker/tm1-mcp-server/compare/v5.0.0...v6.0.0
 [5.0.0]: https://github.com/ffschrattenecker/tm1-mcp-server/compare/v4.1.0...v5.0.0
 [4.1.0]: https://github.com/ffschrattenecker/tm1-mcp-server/compare/v4.0.0...v4.1.0

package/README.md

@@ -86,6 +86,7 @@ TM1_PASSWORD=your-password
 TM1_SSL_REJECT_UNAUTHORIZED=false
 TM1_VERSION=11.8
 TM1_MODE=readonly                   # readonly (default) | readwrite
+# TM1_ENVIRONMENT=prod              # dev | test | prod; prod forces readonly
 # TM1_RESPONSE_MODE=structured      # legacy (default) | structured
 # TM1_MAX_RESPONSE_CHARS=80000      # larger results fail with RESPONSE_TOO_LARGE
 # TM1_LOCAL_FILE_ROOT=/srv/tm1-git  # optional; enables host-disk file params
@@ -103,7 +104,9 @@ Analytics Engine) connection and its auth modes, host-disk file access.
 > tools are registered, so it cannot mutate or delete anything. Set
 > `TM1_MODE=readwrite` explicitly to enable the full lifecycle (cell writes,
 > cube/dimension/process deletion, TI execution), and never point a `readwrite`
-> server at production without reviewing the write path first.
+> server at production without reviewing the write path first. Label production
+> with `TM1_ENVIRONMENT=prod`: it then stays readonly even under
+> `TM1_MODE=readwrite`, unless `TM1_ALLOW_PROD_WRITES=true` is set as well.
 
 Host-disk file access is default-off in the same spirit: the `.pro` and git
 tools accept inline content, and touch host paths only once
@@ -181,7 +184,7 @@ security notes and the `autoApprove` allowlist:
 
 ## Compatibility
 
-- Node.js >= 20
+- Node.js >= 22.19
 - TM1 11.8 / Planning Analytics 2.0 — the primary target; some metadata-write
   paths assume 11.x semantics, and v12-only fields (e.g.
   `DataSource.usesUnicode`) are dropped when `TM1_VERSION` says `11.x`

package/dist/config.d.ts

@@ -18,6 +18,8 @@ export interface TM1Config {
     httpAllowedOrigins: string[];
     httpToken?: string | undefined;
     mode: "readwrite" | "readonly";
+    environment?: "dev" | "test" | "prod" | undefined;
+    modeReason?: string | undefined;
     responseMode: "legacy" | "structured";
     maxResponseChars: number;
     version: 11 | 12;
@@ -31,5 +33,5 @@ export interface TM1Config {
     iamUrl?: string | undefined;
 }
 export declare const DEFAULT_MAX_RESPONSE_CHARS = 80000;
-export declare function loadConfig(): TM1Config;
+export declare function loadConfig(env?: NodeJS.ProcessEnv): TM1Config;
 //# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -1,6 +1,7 @@
 const VALID_LOG_LEVELS = ["debug", "info", "warn", "error"];
 const VALID_TRANSPORTS = ["stdio", "http"];
 const VALID_MODES = ["readwrite", "readonly"];
+const VALID_ENVIRONMENTS = ["dev", "test", "prod"];
 const VALID_RESPONSE_MODES = ["legacy", "structured"];
 const VALID_AUTH_MODES = [
     "s2s",
@@ -22,10 +23,12 @@ function parseIntEnv(name, raw, def) {
     }
     return n;
 }
-export function loadConfig() {
-    const baseUrl = process.env.TM1_BASE_URL;
-    const user = process.env.TM1_USER;
-    const password = process.env.TM1_PASSWORD;
+// `env` defaults to the process environment. The multi-connection registry
+// passes one record per connection folder instead (see ./connections.ts).
+export function loadConfig(env = process.env) {
+    const baseUrl = env.TM1_BASE_URL;
+    const user = env.TM1_USER;
+    const password = env.TM1_PASSWORD;
     // CAM auth (mirrors TM1py's RestService._build_authorization_token):
     //   TM1_CAM_PASSPORT set → "CAMPassport <token>"      (no user/password round-trip)
     //   TM1_NAMESPACE set     → "CAMNamespace b64(u:p:ns)" (needs user + password + namespace)
@@ -33,8 +36,8 @@ export function loadConfig() {
     // SSO/gateway (Windows SSPI) is intentionally unsupported here: TM1py only does
     // it via the Windows-only requests_negotiate_sspi package. Supply a passport
     // obtained out-of-band via TM1_CAM_PASSPORT instead.
-    const namespace = process.env.TM1_NAMESPACE || undefined;
-    const camPassport = process.env.TM1_CAM_PASSPORT || undefined;
+    const namespace = env.TM1_NAMESPACE || undefined;
+    const camPassport = env.TM1_CAM_PASSPORT || undefined;
     // Required: baseUrl always. user/password only when NOT using a passport — a
     // passport carries the authenticated identity, so TM1 needs no credentials.
     // Empty strings are rejected (treated as unset). Password may be empty — some
@@ -57,24 +60,24 @@ export function loadConfig() {
         process.stderr.write("[tm1-mcp-server] WARNING: TM1_PASSWORD is empty. " +
             "If TM1 rejects with 401, check whether the account actually allows blank passwords.\n");
     }
-    const sslRaw = process.env.TM1_SSL_REJECT_UNAUTHORIZED;
+    const sslRaw = env.TM1_SSL_REJECT_UNAUTHORIZED;
     const rejectUnauthorized = sslRaw === undefined ? true : sslRaw !== "false";
-    const keepAliveIntervalMs = parseIntEnv("TM1_KEEP_ALIVE_INTERVAL", process.env.TM1_KEEP_ALIVE_INTERVAL, 60000);
-    const requestTimeoutMs = parseIntEnv("TM1_REQUEST_TIMEOUT", process.env.TM1_REQUEST_TIMEOUT, 30000);
-    const logLevelRaw = process.env.TM1_LOG_LEVEL ?? "info";
+    const keepAliveIntervalMs = parseIntEnv("TM1_KEEP_ALIVE_INTERVAL", env.TM1_KEEP_ALIVE_INTERVAL, 60000);
+    const requestTimeoutMs = parseIntEnv("TM1_REQUEST_TIMEOUT", env.TM1_REQUEST_TIMEOUT, 30000);
+    const logLevelRaw = env.TM1_LOG_LEVEL ?? "info";
     const logLevel = VALID_LOG_LEVELS.includes(logLevelRaw)
         ? logLevelRaw
         : "info";
-    const logFile = process.env.TM1_LOG_FILE || undefined;
-    const tm1Version = process.env.TM1_VERSION || "11.8";
-    const transportRaw = process.env.TM1_MCP_TRANSPORT ?? "stdio";
+    const logFile = env.TM1_LOG_FILE || undefined;
+    const tm1Version = env.TM1_VERSION || "11.8";
+    const transportRaw = env.TM1_MCP_TRANSPORT ?? "stdio";
     const transport = VALID_TRANSPORTS.includes(transportRaw)
         ? transportRaw
         : "stdio";
     // Default to loopback. Binding to 0.0.0.0 must be opt-in to avoid exposing
     // a TM1-credentialed MCP server to the LAN by accident.
-    const httpHost = process.env.TM1_MCP_HTTP_HOST || "127.0.0.1";
-    const httpPort = parseIntEnv("TM1_MCP_HTTP_PORT", process.env.TM1_MCP_HTTP_PORT, 3000);
+    const httpHost = env.TM1_MCP_HTTP_HOST || "127.0.0.1";
+    const httpPort = parseIntEnv("TM1_MCP_HTTP_PORT", env.TM1_MCP_HTTP_PORT, 3000);
     // Origin allow-list for DNS-rebinding protection. Loopback origins are
     // always included so localhost dev clients work out of the box; if the
     // server binds to a non-loopback host we add http://<host>:<port> too.
@@ -89,7 +92,7 @@ export function loadConfig() {
         httpHost !== "0.0.0.0") {
         defaultOrigins.push(`http://${httpHost}:${httpPort}`);
     }
-    const extraOriginsRaw = process.env.TM1_MCP_HTTP_ALLOWED_ORIGINS;
+    const extraOriginsRaw = env.TM1_MCP_HTTP_ALLOWED_ORIGINS;
     const extraOrigins = extraOriginsRaw
         ? extraOriginsRaw
             .split(",")
@@ -97,7 +100,7 @@ export function loadConfig() {
             .filter(Boolean)
         : [];
     const httpAllowedOrigins = Array.from(new Set([...defaultOrigins, ...extraOrigins]));
-    const httpToken = process.env.TM1_MCP_HTTP_TOKEN || undefined;
+    const httpToken = env.TM1_MCP_HTTP_TOKEN || undefined;
     // Refuse a non-loopback HTTP bind without transport auth: TM1_MCP_HTTP_HOST=0.0.0.0
     // (or any LAN address) with no bearer token would expose an unauthenticated,
     // TM1-credentialed /mcp endpoint to the network. Loopback binds keep the
@@ -115,27 +118,40 @@ export function loadConfig() {
     // than silently falling back to readonly (dropping every write tool without a
     // word). A genuinely-unknown value throws at startup — parity with the numeric
     // env vars — instead of failing quietly.
-    const modeRaw = (process.env.TM1_MODE ?? "readonly").trim().toLowerCase();
+    const modeRaw = (env.TM1_MODE ?? "readonly").trim().toLowerCase();
     if (!VALID_MODES.includes(modeRaw)) {
-        throw new Error(`Invalid TM1_MODE: "${process.env.TM1_MODE}". Expected "readwrite" or "readonly".`);
+        throw new Error(`Invalid TM1_MODE: "${env.TM1_MODE}". Expected "readwrite" or "readonly".`);
+    }
+    const envRaw = env.TM1_ENVIRONMENT?.trim().toLowerCase() || undefined;
+    if (envRaw !== undefined &&
+        !VALID_ENVIRONMENTS.includes(envRaw)) {
+        throw new Error(`Invalid TM1_ENVIRONMENT: "${env.TM1_ENVIRONMENT}". Expected "dev", "test" or "prod".`);
+    }
+    const environment = envRaw;
+    const allowProdWrites = env.TM1_ALLOW_PROD_WRITES?.trim().toLowerCase() === "true";
+    let mode = modeRaw;
+    let modeReason;
+    if (environment === "prod" && mode === "readwrite" && !allowProdWrites) {
+        mode = "readonly";
+        modeReason =
+            "TM1_ENVIRONMENT=prod forces readonly; set TM1_ALLOW_PROD_WRITES=true to allow writes.";
     }
-    const mode = modeRaw;
     // Same parse shape as TM1_MODE: case-insensitive, unknown value throws at
     // startup rather than silently picking a wire format the operator did not ask
     // for.
-    const responseModeRaw = (process.env.TM1_RESPONSE_MODE ?? "legacy")
+    const responseModeRaw = (env.TM1_RESPONSE_MODE ?? "legacy")
         .trim()
         .toLowerCase();
     if (!VALID_RESPONSE_MODES.includes(responseModeRaw)) {
-        throw new Error(`Invalid TM1_RESPONSE_MODE: "${process.env.TM1_RESPONSE_MODE}". Expected "legacy" or "structured".`);
+        throw new Error(`Invalid TM1_RESPONSE_MODE: "${env.TM1_RESPONSE_MODE}". Expected "legacy" or "structured".`);
     }
     const responseMode = responseModeRaw;
     // ~80k characters sits under Claude Code's default MCP output cap (25k
     // tokens) with room for the envelope; 23 recorded results overflowed it.
-    const maxResponseChars = parseIntEnv("TM1_MAX_RESPONSE_CHARS", process.env.TM1_MAX_RESPONSE_CHARS, DEFAULT_MAX_RESPONSE_CHARS);
+    const maxResponseChars = parseIntEnv("TM1_MAX_RESPONSE_CHARS", env.TM1_MAX_RESPONSE_CHARS, DEFAULT_MAX_RESPONSE_CHARS);
     // --- v12 (Planning Analytics Engine) connection ---------------------------
-    const instance = process.env.TM1_INSTANCE || undefined;
-    const database = process.env.TM1_DATABASE || undefined;
+    const instance = env.TM1_INSTANCE || undefined;
+    const database = env.TM1_DATABASE || undefined;
     const versionMajor = Number.parseInt(tm1Version, 10);
     const isV12 = Boolean(instance || database) || versionMajor === 12;
     const version = isV12 ? 12 : 11;
@@ -159,19 +175,17 @@ export function loadConfig() {
         if (!database) {
             throw new Error("v12 connection requires TM1_DATABASE (set alongside TM1_INSTANCE).");
         }
-        const authModeRaw = (process.env.TM1_AUTH_MODE ?? "s2s")
-            .trim()
-            .toLowerCase();
+        const authModeRaw = (env.TM1_AUTH_MODE ?? "s2s").trim().toLowerCase();
         if (!VALID_AUTH_MODES.includes(authModeRaw)) {
-            throw new Error(`Invalid TM1_AUTH_MODE: "${process.env.TM1_AUTH_MODE}". ` +
+            throw new Error(`Invalid TM1_AUTH_MODE: "${env.TM1_AUTH_MODE}". ` +
                 `Expected one of: ${VALID_AUTH_MODES.join(", ")}.`);
         }
         authMode = authModeRaw;
-        clientId = process.env.TM1_CLIENT_ID || undefined;
-        clientSecret = process.env.TM1_CLIENT_SECRET || undefined;
-        accessToken = process.env.TM1_ACCESS_TOKEN || undefined;
-        apiKey = process.env.TM1_API_KEY || undefined;
-        iamUrl = process.env.TM1_IAM_URL || undefined;
+        clientId = env.TM1_CLIENT_ID || undefined;
+        clientSecret = env.TM1_CLIENT_SECRET || undefined;
+        accessToken = env.TM1_ACCESS_TOKEN || undefined;
+        apiKey = env.TM1_API_KEY || undefined;
+        iamUrl = env.TM1_IAM_URL || undefined;
         const missingV12 = [];
         // Every v12 mode — not just "basic" — sends `{ User: config.user }` in the
         // session login body (profile.ts buildLoginRequest), so TM1_USER is required
@@ -222,6 +236,8 @@ export function loadConfig() {
         httpAllowedOrigins,
         httpToken,
         mode,
+        ...(environment !== undefined ? { environment } : {}),
+        ...(modeReason !== undefined ? { modeReason } : {}),
         responseMode,
         maxResponseChars,
         version,

package/dist/index.js

@@ -77,7 +77,10 @@ async function main() {
     catch (err) {
         logger.warn({ err }, "Initial TM1 connection failed — server will retry on first tool call");
     }
-    if (config.mode === "readonly") {
+    if (config.modeReason) {
+        logger.warn(`${config.modeReason} Write and destructive tools will not be registered.`);
+    }
+    else if (config.mode === "readonly") {
         logger.info("TM1_MODE=readonly — write and destructive tools will not be registered");
     }
     // Branch on transport. stdio is the default for local MCP-client setups

package/dist/tm1-client.d.ts

@@ -38,6 +38,12 @@ export declare class TM1Client {
     constructor(config: TM1Config, sessionManager: SessionManager, logger: pino.Logger);
     /** The configured TM1 major version (11 or 12). Fixed for this connection. */
     get version(): 11 | 12;
+    /** Effective tool mode, the environment label, and why mode was forced. */
+    get access(): {
+        mode: TM1Config["mode"];
+        environment: TM1Config["environment"];
+        modeReason: string | undefined;
+    };
     /**
      * Stable label for this connection, used to keep per-connection files (the
      * process backups) apart: host and port, plus the v12 instance/database.

package/dist/tm1-client.js

@@ -82,6 +82,14 @@ export class TM1Client {
     get version() {
         return this.config.version;
     }
+    /** Effective tool mode, the environment label, and why mode was forced. */
+    get access() {
+        return {
+            mode: this.config.mode,
+            environment: this.config.environment,
+            modeReason: this.config.modeReason,
+        };
+    }
     /**
      * Stable label for this connection, used to keep per-connection files (the
      * process backups) apart: host and port, plus the v12 instance/database.

package/dist/tools/analysis/analyze-object-usage.d.ts

@@ -1,2 +1,12 @@
+import { buildCubeOrDimUsages } from "../../lib/callgraph/callGraph.js";
 export declare const registerAnalyzeObjectUsage: import("../define-tool.js").ToolRegistrar;
+/** One row per referencing process or rule, most references first. */
+export declare function summarizeBySource(all: ReturnType<typeof buildCubeOrDimUsages>): {
+    sourceKind: "process" | "rule";
+    sourceName: string;
+    accessTypes: string[];
+    sections: string[];
+    funcNames: string[];
+    count: number;
+}[];
 //# sourceMappingURL=analyze-object-usage.d.ts.map

package/dist/tools/analysis/analyze-object-usage.js

@@ -64,39 +64,7 @@ export const registerAnalyzeObjectUsage = defineTool({
             accessMode,
         });
         if (mode === "summary") {
-            // Aggregate per source (process or rule). Key by kind+name so a process
-            // and a cube-rule sharing a name don't collapse into one row.
-            const bySource = new Map();
-            for (const u of all) {
-                const key = `${u.sourceKind}\x00${u.sourceName}`;
-                let s = bySource.get(key);
-                if (!s) {
-                    s = {
-                        sourceKind: u.sourceKind,
-                        sourceName: u.sourceName,
-                        accessTypes: new Set(),
-                        sections: new Set(),
-                        funcNames: new Set(),
-                        count: 0,
-                    };
-                    bySource.set(key, s);
-                }
-                s.accessTypes.add(u.accessType);
-                s.sections.add(u.section);
-                if (u.funcName)
-                    s.funcNames.add(u.funcName);
-                s.count++;
-            }
-            const allSources = [...bySource.values()]
-                .map((s) => ({
-                sourceKind: s.sourceKind,
-                sourceName: s.sourceName,
-                accessTypes: [...s.accessTypes].sort(),
-                sections: [...s.sections].sort(),
-                funcNames: [...s.funcNames].sort(),
-                count: s.count,
-            }))
-                .sort((a, b) => b.count - a.count || a.sourceName.localeCompare(b.sourceName));
+            const allSources = summarizeBySource(all);
             const sumTruncated = allSources.length > effectiveLimit;
             const sources = sumTruncated
                 ? allSources.slice(0, effectiveLimit)
@@ -140,4 +108,40 @@ export const registerAnalyzeObjectUsage = defineTool({
         };
     },
 });
+/** One row per referencing process or rule, most references first. */
+export function summarizeBySource(all) {
+    // Aggregate per source (process or rule). Key by kind+name so a process
+    // and a cube-rule sharing a name don't collapse into one row.
+    const bySource = new Map();
+    for (const u of all) {
+        const key = `${u.sourceKind}\x00${u.sourceName}`;
+        let s = bySource.get(key);
+        if (!s) {
+            s = {
+                sourceKind: u.sourceKind,
+                sourceName: u.sourceName,
+                accessTypes: new Set(),
+                sections: new Set(),
+                funcNames: new Set(),
+                count: 0,
+            };
+            bySource.set(key, s);
+        }
+        s.accessTypes.add(u.accessType);
+        s.sections.add(u.section);
+        if (u.funcName)
+            s.funcNames.add(u.funcName);
+        s.count++;
+    }
+    return [...bySource.values()]
+        .map((s) => ({
+        sourceKind: s.sourceKind,
+        sourceName: s.sourceName,
+        accessTypes: [...s.accessTypes].sort(),
+        sections: [...s.sections].sort(),
+        funcNames: [...s.funcNames].sort(),
+        count: s.count,
+    }))
+        .sort((a, b) => b.count - a.count || a.sourceName.localeCompare(b.sourceName));
+}
 //# sourceMappingURL=analyze-object-usage.js.map

package/dist/tools/analysis/delete-impact.d.ts

@@ -0,0 +1,13 @@
+import type { TM1Client } from "../../tm1-client.js";
+export declare function deleteImpact(tm1Client: TM1Client, kind: "cube" | "dimension", name: string): Promise<{
+    sources: {
+        sourceKind: "process" | "rule";
+        sourceName: string;
+        accessTypes: string[];
+        count: number;
+    }[];
+    truncated?: boolean;
+    referencingSources: number;
+    usedInCubes?: string[];
+}>;
+//# sourceMappingURL=delete-impact.d.ts.map

package/dist/tools/analysis/delete-impact.js

@@ -0,0 +1,30 @@
+import { buildIndexFromTM1 } from "../../lib/callgraph/tm1-adapter.js";
+import { buildCubeOrDimUsages } from "../../lib/callgraph/callGraph.js";
+import { summarizeBySource } from "./analyze-object-usage.js";
+const MAX_SOURCES = 50;
+export async function deleteImpact(tm1Client, kind, name) {
+    const [index, cubes] = await Promise.all([
+        buildIndexFromTM1(tm1Client, { includeControl: false }),
+        kind === "dimension" ? tm1Client.cubes.list() : Promise.resolve([]),
+    ]);
+    const sources = summarizeBySource(buildCubeOrDimUsages(index, kind, name, {
+        includeSystem: false,
+        accessMode: "all",
+    }));
+    const key = name.toLowerCase();
+    const usedInCubes = cubes
+        .filter((c) => (c.dimensions ?? []).some((d) => d.toLowerCase() === key))
+        .map((c) => c.name);
+    return {
+        ...(kind === "dimension" ? { usedInCubes } : {}),
+        referencingSources: sources.length,
+        ...(sources.length > MAX_SOURCES ? { truncated: true } : {}),
+        sources: sources.slice(0, MAX_SOURCES).map((s) => ({
+            sourceKind: s.sourceKind,
+            sourceName: s.sourceName,
+            accessTypes: s.accessTypes,
+            count: s.count,
+        })),
+    };
+}
+//# sourceMappingURL=delete-impact.js.map

package/dist/tools/celldata/write-cells.js

@@ -6,6 +6,12 @@ import { MutationResultSchema } from "../schemas/items.js";
 import { defineTool } from "../define-tool.js";
 import { dimensionCountMismatch } from "../../lib/coordinate-error.js";
 import { resolveCellAddress } from "../../lib/cell-address.js";
+const READ_BACK_LIMIT = 20;
+function sameValue(sent, stored) {
+    if (typeof sent === "number")
+        return Number(stored) === sent;
+    return String(stored ?? "") === sent;
+}
 export const registerWriteCells = defineTool({
     name: "tm1_write_cells",
     description: [
@@ -14,7 +20,8 @@ export const registerWriteCells = defineTool({
         "Writes to consolidated cells are rejected by TM1.",
         "Every cube dimension must be named (any order) — a dimension left out would land on its default member, so the call is refused. Only Sandboxes may be left out: it is bound to Base and echoed as sandboxDefaulted. A named sandbox is addressable only once its IncludeInSandboxDimension is true.",
         "Before: tm1_check_writable_coords to validate that target coordinates are leaf-level and addressable.",
-        "Related: tm1_clear_cube for bulk wipe, tm1_get_cell_value to read back, tm1_execute_process for production data loads.",
+        "The written cells are read back (up to 20; verified.mismatches lists any that differ, e.g. a rule or spread overriding the value), so no separate tm1_get_cell_value is needed.",
+        "Related: tm1_clear_cube for bulk wipe, tm1_execute_process for production data loads.",
     ],
     annotations: DESTRUCTIVE,
     output: MutationResultSchema,
@@ -52,10 +59,38 @@ export const registerWriteCells = defineTool({
         // propagate to the index.ts Proxy unwrapped — wrapping it here would
         // clobber that hint with a generic one.
         const address = resolveCellAddress(cubeName, await tm1Client.cubes.getDimensionNames(cubeName), dimensions);
-        await tm1Client.cells.writeCells(cubeName, address.dimensions, cells.map((c) => ({ ...c, elements: address.toCubeOrder(c.elements) })));
+        const ordered = cells.map((c) => ({
+            ...c,
+            elements: address.toCubeOrder(c.elements),
+        }));
+        await tm1Client.cells.writeCells(cubeName, address.dimensions, ordered);
+        // Read back a bounded sample: each read is its own MDX round trip. The
+        // write has landed by now, so a failed read-back is reported, not thrown.
+        const sample = ordered.slice(0, READ_BACK_LIMIT);
+        let verified;
+        try {
+            const readBack = await Promise.all(sample.map((c) => tm1Client.cells.getValue(cubeName, c.elements)));
+            verified = {
+                checked: sample.length,
+                ...(cells.length > sample.length
+                    ? { unchecked: cells.length - sample.length }
+                    : {}),
+                mismatches: sample
+                    .map((c, i) => ({
+                    elements: c.elements,
+                    sent: c.value,
+                    stored: readBack[i],
+                }))
+                    .filter((m) => !sameValue(m.sent, m.stored)),
+            };
+        }
+        catch (e) {
+            verified = { checked: 0, readBackError: e.message };
+        }
         return actionResponse({
             success: true,
             cellsWritten: cells.length,
+            verified,
             ...(address.sandboxDefaulted
                 ? { sandboxDefaulted: address.sandboxDefaulted }
                 : {}),

package/dist/tools/confirm.d.ts

@@ -2,7 +2,10 @@ import { z } from "zod";
 export declare const CONFIRM_SCHEMA: {
     confirm: z.ZodString;
 };
-export declare function requireConfirm(provided: string, target: string, kind: string): void;
+export declare const DRY_RUN_CONFIRM_SCHEMA: {
+    confirm: z.ZodOptional<z.ZodString>;
+};
+export declare function requireConfirm(provided: string | undefined, target: string, kind: string): void;
 export declare const OVERWRITE_CONFIRM_SCHEMA: {
     confirm: z.ZodOptional<z.ZodString>;
 };

package/dist/tools/confirm.js

@@ -29,11 +29,21 @@ export const CONFIRM_SCHEMA = {
         .string()
         .describe("Safety check: repeat the target identifier verbatim (e.g. cube/dimension/process name) to confirm this irreversible action. Mismatched values reject the call."),
 };
+// For a destructive tool with a dryRun: a dry run needs no confirm, so the
+// field is optional in the schema and required at runtime on the real call.
+export const DRY_RUN_CONFIRM_SCHEMA = {
+    confirm: z
+        .string()
+        .optional()
+        .describe("Required unless dryRun=true: repeat the target identifier verbatim to confirm this irreversible action. A dry run is not a confirmation."),
+};
 export function requireConfirm(provided, target, kind) {
     if (provided !== target) {
         throw new TM1Error({
             code: TM1ErrorCode.VALIDATION_ERROR,
-            message: `confirm mismatch — expected ${kind} name "${target}", got "${provided}".`,
+            message: provided === undefined
+                ? `This call is irreversible for ${kind} "${target}" and needs confirm="${target}". Nothing was changed.`
+                : `confirm mismatch — expected ${kind} name "${target}", got "${provided}".`,
             hint: `Re-issue the call with confirm="${target}" verbatim. This safety check prevents accidental destructive operations.`,
         });
     }

package/dist/tools/dimension-management/delete-dimension.js

@@ -1,22 +1,36 @@
 import { z } from "zod";
 import { actionResponse } from "../format.js";
-import { CONFIRM_SCHEMA, requireConfirm } from "../confirm.js";
+import { DRY_RUN_CONFIRM_SCHEMA, requireConfirm } from "../confirm.js";
 import { DESTRUCTIVE } from "../annotations.js";
 import { MutationResultSchema } from "../schemas/items.js";
 import { defineTool } from "../define-tool.js";
+import { deleteImpact } from "../analysis/delete-impact.js";
 export const registerDeleteDimension = defineTool({
     name: "tm1_delete_dimension",
     description: [
         "Delete a TM1 dimension and all its hierarchies. Warning: fails if the dimension is used in a cube.",
-        "Before: tm1_find_orphan_dimensions to confirm the dimension is unused, or tm1_analyze_object_usage for a targeted check.",
+        "Before: dryRun=true lists the cubes that contain it and every process or rule that references it, in one call.",
     ],
     annotations: DESTRUCTIVE,
     output: MutationResultSchema,
     input: {
         dimensionName: z.string().describe("Dimension name (case-sensitive)"),
-        ...CONFIRM_SCHEMA,
+        dryRun: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Delete nothing: return what references the dimension (processes and rules, per source) and the cubes it is part of. Needs no confirm and is not one."),
+        ...DRY_RUN_CONFIRM_SCHEMA,
     },
-    handler: async ({ dimensionName, confirm }, tm1Client) => {
+    handler: async ({ dimensionName, dryRun, confirm }, tm1Client) => {
+        if (dryRun) {
+            return actionResponse({
+                success: true,
+                dryRun: true,
+                dimensionName,
+                impact: await deleteImpact(tm1Client, "dimension", dimensionName),
+            });
+        }
         requireConfirm(confirm, dimensionName, "dimension");
         await tm1Client.dimensions.delete(dimensionName);
         return actionResponse({ success: true, dimensionName });