@ffschrattenecker/tm1-mcp-server 6.0.0

package/dist/lib/v12-compat/deprecated-ti.js

@@ -0,0 +1,257 @@
+// Canonical list of TI functions removed in TM1 / Planning Analytics v12
+// (Cloud Native engine).
+//
+// Source of truth: vscode-tm1-ti repo, src/tiLogicVisualizer/tiSignatures.ts
+// Synced from commit cf73b93 ("fix(webview): robust Ctrl+V paste path + ...")
+// on 2026-05-12. Each entry there carries a `deprecatedInV12: true` flag.
+//
+// Sync procedure: when IBM publishes new PA Cloud release notes or the
+// upstream signatures file changes, re-extract from vscode-tm1-ti's
+// tiSignatures.ts (entries flagged `deprecatedInV12: true`) and update the
+// list below, bumping the source commit reference above.
+// Keyed by lowercase name (TI is case-insensitive).
+export const V12_DEPRECATED_TI = new Map([
+    {
+        name: "AddInfoCubeRestriction",
+        severity: "error",
+        issue: "Cube restriction API removed in v12 — security moves to Cloud IAM",
+        suggestion: "Configure via Cloud admin or PA Workspace security",
+    },
+    {
+        name: "AllowExternalRequests",
+        severity: "error",
+        issue: "External-request toggle removed in v12",
+        suggestion: "Remove without replacement — external calls go through the PA connector layer",
+    },
+    {
+        name: "AssignClientPassword",
+        severity: "error",
+        issue: "TI-based password management removed in v12",
+        suggestion: "Manage identity via Cloud IAM/SCIM",
+    },
+    {
+        name: "AssociateCAMIDToGroup",
+        severity: "error",
+        issue: "CAM security mapping via TI no longer supported in v12",
+        suggestion: "Maintain group mapping via Cloud admin",
+    },
+    {
+        name: "BatchCellIncrement",
+        severity: "error",
+        issue: "Batch cell API removed in v12",
+        suggestion: "Use a regular CellPutN/CellIncrementN loop",
+    },
+    {
+        name: "BatchUpdateFinish",
+        severity: "error",
+        issue: "BatchUpdate mode removed in v12 — the cloud engine optimizes automatically",
+        suggestion: "Remove without replacement",
+    },
+    {
+        name: "BatchUpdateFinishWait",
+        severity: "error",
+        issue: "BatchUpdate mode removed in v12",
+        suggestion: "Remove without replacement",
+    },
+    {
+        name: "BatchUpdateStart",
+        severity: "error",
+        issue: "BatchUpdate mode removed in v12",
+        suggestion: "Remove without replacement",
+    },
+    {
+        name: "CGAddPromptValues",
+        severity: "error",
+        issue: "Cognos Gateway prompts removed in v12",
+        suggestion: "Remodel the workflow in PA Workspace",
+    },
+    {
+        name: "CGPromptGetNextMember",
+        severity: "error",
+        issue: "Cognos Gateway prompts removed in v12",
+        suggestion: "Remodel the workflow in PA Workspace",
+    },
+    {
+        name: "CGPromptSize",
+        severity: "error",
+        issue: "Cognos Gateway prompts removed in v12",
+        suggestion: "Remodel the workflow in PA Workspace",
+    },
+    {
+        name: "CreateHierarchyByAttribute",
+        severity: "error",
+        issue: "Auto hierarchy builder removed in v12",
+        suggestion: "Build the hierarchy manually via REST API/TI loop",
+    },
+    {
+        name: "CubeDataReservationAcquire",
+        severity: "error",
+        issue: "Data reservation API removed in v12",
+        suggestion: "Model locking via process lock / sandbox workflow",
+    },
+    {
+        name: "CubeDataReservationGet",
+        severity: "error",
+        issue: "Data reservation API removed in v12",
+        suggestion: "Model locking via process lock / sandbox workflow",
+    },
+    {
+        name: "CubeDataReservationGetConflicts",
+        severity: "error",
+        issue: "Data reservation API removed in v12",
+        suggestion: "Model locking via process lock / sandbox workflow",
+    },
+    {
+        name: "CubeDataReservationRelease",
+        severity: "error",
+        issue: "Data reservation API removed in v12",
+        suggestion: "Model locking via process lock / sandbox workflow",
+    },
+    {
+        name: "CubeDataReservationReleaseAll",
+        severity: "error",
+        issue: "Data reservation API removed in v12",
+        suggestion: "Model locking via process lock / sandbox workflow",
+    },
+    {
+        name: "CubeGetLogChanges",
+        severity: "error",
+        issue: "Cube LogChanges toggle removed in v12 — logging is centralized",
+        suggestion: "Remove without replacement",
+    },
+    {
+        name: "CubeSaveData",
+        severity: "error",
+        issue: "Manual persistence removed in v12 — the cloud engine persists automatically",
+        suggestion: "Remove without replacement",
+    },
+    {
+        name: "CubeSetConnParams",
+        severity: "error",
+        issue: "Connection params via TI removed in v12",
+        suggestion: "Configure data sources via the admin UI",
+    },
+    {
+        name: "CubeSetLogChanges",
+        severity: "error",
+        issue: "Cube LogChanges toggle removed in v12",
+        suggestion: "Remove without replacement",
+    },
+    {
+        name: "CubeUnload",
+        severity: "error",
+        issue: "Cube unload via TI removed in v12",
+        suggestion: "Use tm1_unload_cube via REST or remove without replacement",
+    },
+    {
+        name: "DisableBulkLoadMode",
+        severity: "error",
+        issue: "BulkLoad mode removed in v12",
+        suggestion: "Remove without replacement — the cloud engine optimizes automatically",
+    },
+    {
+        name: "EnableBatchCellIncrement",
+        severity: "error",
+        issue: "Batch cell API removed in v12",
+        suggestion: "Remove without replacement",
+    },
+    {
+        name: "EnableBulkLoadMode",
+        severity: "error",
+        issue: "BulkLoad mode removed in v12",
+        suggestion: "Remove without replacement — the cloud engine optimizes automatically",
+    },
+    {
+        name: "ExecuteCommand",
+        severity: "error",
+        issue: "Shell execution removed in v12 (cloud sandbox allows no OS calls)",
+        suggestion: "Orchestrate external steps via CI/CD/PA connector",
+    },
+    {
+        name: "ExecuteJavaN",
+        severity: "error",
+        issue: "Java bridge removed in v12",
+        suggestion: "Port the logic to TI/rules or use an external service",
+    },
+    {
+        name: "ExecuteJavaS",
+        severity: "error",
+        issue: "Java bridge removed in v12",
+        suggestion: "Port the logic to TI/rules or use an external service",
+    },
+    {
+        name: "LockOff",
+        severity: "error",
+        issue: "TI lock toggle removed in v12",
+        suggestion: "Remove without replacement — locking via the sandbox model",
+    },
+    {
+        name: "LockOn",
+        severity: "error",
+        issue: "TI lock toggle removed in v12",
+        suggestion: "Remove without replacement — locking via the sandbox model",
+    },
+    {
+        name: "RefreshMDXHierarchy",
+        severity: "error",
+        issue: "MDX refresh hook removed in v12",
+        suggestion: "Remove without replacement — the engine refreshes automatically",
+    },
+    {
+        name: "RemoveCAMIDAssociation",
+        severity: "error",
+        issue: "CAM security mapping via TI no longer supported in v12",
+        suggestion: "Maintain mapping via Cloud admin",
+    },
+    {
+        name: "RemoveCAMIDAssociationFromGroup",
+        severity: "error",
+        issue: "CAM security mapping via TI no longer supported in v12",
+        suggestion: "Maintain mapping via Cloud admin",
+    },
+    {
+        name: "SaveDataAll",
+        severity: "error",
+        issue: "SaveDataAll removed in v12 — the cloud engine persists automatically",
+        suggestion: "Remove without replacement",
+    },
+    {
+        name: "ServerShutdown",
+        severity: "error",
+        issue: "Server shutdown via TI removed in v12 (cloud-managed)",
+        suggestion: "Remove without replacement",
+    },
+    {
+        name: "SetChoreVerboseMessages",
+        severity: "warning",
+        issue: "Chore verbose toggle removed in v12",
+        suggestion: "Consume logging via central logs",
+    },
+    {
+        name: "SetOdbcUnicodeInterface",
+        severity: "error",
+        issue: "ODBC data sources removed in v12 — external connector required",
+        suggestion: "Connect data via PA cloud connector / Files API",
+    },
+    {
+        name: "SwapAliasWithPrincipalName",
+        severity: "error",
+        issue: "Alias swap helper removed in v12",
+        suggestion: "Model explicitly via AttributePutS() operations",
+    },
+].map((e) => [
+    e.name.toLowerCase(),
+    e,
+]));
+/**
+ * Combined case-insensitive regex matching any deprecated function name
+ * followed by `(`. Used by the scanner for a single-pass-per-line match.
+ */
+export const V12_DEPRECATED_TI_REGEX = (() => {
+    const alternation = Array.from(V12_DEPRECATED_TI.values())
+        .map((e) => e.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+        .sort((a, b) => b.length - a.length)
+        .join("|");
+    return new RegExp(`\\b(${alternation})\\s*\\(`, "gi");
+})();
+//# sourceMappingURL=deprecated-ti.js.map

package/dist/lib/v12-compat/scanner.d.ts

@@ -0,0 +1,10 @@
+export interface ScanHit {
+    line: number;
+    function: string;
+    snippet: string;
+    severity: "error" | "warning";
+    issue: string;
+    suggestion: string;
+}
+export declare function scanForDeprecatedTi(text: string): ScanHit[];
+//# sourceMappingURL=scanner.d.ts.map

package/dist/lib/v12-compat/scanner.js

@@ -0,0 +1,43 @@
+// Line-oriented scanner that finds deprecated-in-v12 TI function calls inside
+// a code block (a TI section body or rules text). Strips '#'-prefixed full-line
+// comments before matching; inline comments are uncommon in TI but accepted as
+// a small false-positive surface in exchange for simplicity.
+import { V12_DEPRECATED_TI, V12_DEPRECATED_TI_REGEX } from "./deprecated-ti.js";
+const SNIPPET_MAX = 200;
+export function scanForDeprecatedTi(text) {
+    if (!text)
+        return [];
+    const hits = [];
+    const lines = text.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        const raw = lines[i];
+        const trimmed = raw.trimStart();
+        if (trimmed.startsWith("#"))
+            continue;
+        const seenOnThisLine = new Set();
+        V12_DEPRECATED_TI_REGEX.lastIndex = 0;
+        let m;
+        while ((m = V12_DEPRECATED_TI_REGEX.exec(raw)) !== null) {
+            const key = m[1].toLowerCase();
+            if (seenOnThisLine.has(key))
+                continue;
+            seenOnThisLine.add(key);
+            const entry = V12_DEPRECATED_TI.get(key);
+            if (!entry)
+                continue;
+            const snippet = raw.trim();
+            hits.push({
+                line: i + 1,
+                function: entry.name,
+                snippet: snippet.length > SNIPPET_MAX
+                    ? snippet.slice(0, SNIPPET_MAX) + "…"
+                    : snippet,
+                severity: entry.severity,
+                issue: entry.issue,
+                suggestion: entry.suggestion,
+            });
+        }
+    }
+    return hits;
+}
+//# sourceMappingURL=scanner.js.map

package/dist/lib/variables-ui-data.d.ts

@@ -0,0 +1,26 @@
+import type { IgnoredColumn } from "../schemas/processes.js";
+/** Field separator inside a VariablesUIData entry (form feed, 0x0C). */
+export declare const UI_DATA_SEPARATOR = "\f";
+/** One datasource column as the Architect UI records it. */
+export interface VariableColumn {
+    /** 1-based column position in the datasource. */
+    position: number;
+    ignored: boolean;
+    /** Variable name the column had before it was set to Ignore, if TM1 kept one. */
+    ignoredName?: string;
+}
+/**
+ * Decode `VariablesUIData` into one entry per datasource column. Returns an
+ * empty array when the process has no UI data (nothing was ever ignored, or the
+ * server was asked without the `$select`).
+ */
+export declare function parseVariableColumns(uiData: readonly string[] | undefined): VariableColumn[];
+/**
+ * The ignored columns alone, ready for tool output. `name` is the variable name
+ * the column carried before it was ignored; TM1 keeps it so the setting can be
+ * undone in Architect.
+ */
+export declare function ignoredColumnsOf(uiData: readonly string[] | undefined): IgnoredColumn[];
+/** Stable key for comparing two ignored-column sets (diff tools). */
+export declare function ignoredColumnKey(column: IgnoredColumn): string;
+//# sourceMappingURL=variables-ui-data.d.ts.map

package/dist/lib/variables-ui-data.js

@@ -0,0 +1,77 @@
+// Datasource columns that a TI process ignores.
+//
+// `Process.Variables` lists only the columns that carry a variable. A column
+// switched to "Ignore" in the Variables tab drops out of that list entirely:
+// its sole trace is `Process.VariablesUIData`, which holds one entry per SOURCE
+// COLUMN — ignored ones included — in column order:
+//
+//   "IgnoredInputVarName=vsSTRN\fVarType=32\fColType=1165\f"   ignored column
+//   "VarType=32\fColType=827\f"                                ordinary column
+//
+// Fields are separated by form feed (0x0C). VarType 32 = String, 33 = Numeric;
+// ColType 1165 = Ignore. Measured on 1022 real .pro files (396 ignored columns
+// across 30 processes, where the flag lives in line block 582) and live against
+// 11.8 and 12.5.
+//
+// Two consequences drive the code below:
+//
+//   - `VariablesUIData` is declared in NEITHER version's $metadata, so a plain
+//     GET never returns it — it has to be named in `$select` (undeclared is not
+//     the same as absent; see the same trap with `Alias`/`Code`).
+//   - The raw strings are carried around verbatim rather than rebuilt from a
+//     parsed form. Only ColType 1165 is measured; 827 dominates and 830 shows
+//     up once in the corpus, so regenerating the array would flatten contents
+//     settings whose meaning has not been established.
+/** Field separator inside a VariablesUIData entry (form feed, 0x0C). */
+export const UI_DATA_SEPARATOR = "\f";
+const IGNORED_COL_TYPE = "1165";
+function fieldsOf(entry) {
+    const fields = new Map();
+    for (const part of entry.split(UI_DATA_SEPARATOR)) {
+        const eq = part.indexOf("=");
+        if (eq === -1)
+            continue;
+        fields.set(part.slice(0, eq), part.slice(eq + 1));
+    }
+    return fields;
+}
+/**
+ * Decode `VariablesUIData` into one entry per datasource column. Returns an
+ * empty array when the process has no UI data (nothing was ever ignored, or the
+ * server was asked without the `$select`).
+ */
+export function parseVariableColumns(uiData) {
+    if (!uiData)
+        return [];
+    return uiData.map((entry, idx) => {
+        const fields = fieldsOf(entry);
+        const ignoredName = fields.get("IgnoredInputVarName");
+        const column = {
+            position: idx + 1,
+            ignored: fields.get("ColType") === IGNORED_COL_TYPE,
+        };
+        // TM1 only writes the remembered name on ignored columns, but a column can
+        // be ignored without one — treat the flag, not the name, as the signal.
+        if (ignoredName !== undefined && ignoredName !== "")
+            column.ignoredName = ignoredName;
+        return column;
+    });
+}
+/**
+ * The ignored columns alone, ready for tool output. `name` is the variable name
+ * the column carried before it was ignored; TM1 keeps it so the setting can be
+ * undone in Architect.
+ */
+export function ignoredColumnsOf(uiData) {
+    return parseVariableColumns(uiData)
+        .filter((c) => c.ignored)
+        .map((c) => ({
+        position: c.position,
+        ...(c.ignoredName !== undefined ? { name: c.ignoredName } : {}),
+    }));
+}
+/** Stable key for comparing two ignored-column sets (diff tools). */
+export function ignoredColumnKey(column) {
+    return `${column.position}:${column.name ?? ""}`;
+}
+//# sourceMappingURL=variables-ui-data.js.map

package/dist/load-env.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=load-env.d.ts.map

package/dist/load-env.js

@@ -0,0 +1,29 @@
+import { config as loadDotenv } from "dotenv";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+// Load environment from .env BEFORE any other module evaluates. MCP clients
+// spawn this binary with THEIR working directory, not the repo's, so the plain
+// `dotenv/config` (which only reads process.cwd()/.env) would never find a repo
+// `.env` — the single most common first-run failure. We additionally resolve
+// `.env` relative to the compiled entrypoint (dist/load-env.js -> ../.env, i.e.
+// the package/repo root) so the documented clone+build setup works regardless of
+// the client's cwd.
+//
+// `DOTENV_CONFIG_PATH` is honored explicitly: dotenv only reads that variable
+// during Node preloading (`node --require dotenv/config`), NOT on a manual
+// `config()` call, so an MCP client that sets it would otherwise fail silently.
+//
+// dotenv never overwrites already-set keys, so precedence is:
+//   real shell / MCP `env:` vars  >  $DOTENV_CONFIG_PATH  >  cwd/.env  >  <packageRoot>/.env
+//
+// `quiet: true` is REQUIRED: dotenv v17 prints "injected env" tips to stdout by
+// default, which would corrupt the JSON-RPC stream on the stdio transport.
+if (process.env.DOTENV_CONFIG_PATH) {
+    loadDotenv({ path: process.env.DOTENV_CONFIG_PATH, quiet: true });
+}
+loadDotenv({ quiet: true });
+loadDotenv({
+    path: join(dirname(fileURLToPath(import.meta.url)), "..", ".env"),
+    quiet: true,
+});
+//# sourceMappingURL=load-env.js.map

package/dist/logger.d.ts

@@ -0,0 +1,4 @@
+import pino from "pino";
+import type { TM1Config } from "./config.js";
+export declare function createLogger(config: Pick<TM1Config, "logLevel" | "logFile">, destination?: pino.DestinationStream): pino.Logger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.js

@@ -0,0 +1,60 @@
+import pino from "pino";
+// "Cookie"/"cookie" are defensive: the TM1SessionId travels as a Cookie header
+// VALUE, which path-based redaction of the field name would miss. No code logs
+// headers today, but a future logger.debug({ headers }) must not leak the session.
+const SENSITIVE_FIELDS = [
+    "password",
+    "Authorization",
+    "TM1SessionId",
+    "Cookie",
+    "cookie",
+    "clientSecret",
+    "accessToken",
+    "apiKey",
+    "camPassport",
+];
+const MASK_VALUE = "***";
+function redactPaths() {
+    const paths = [];
+    for (const field of SENSITIVE_FIELDS) {
+        paths.push(field);
+        paths.push(`*.${field}`);
+        paths.push(`headers.${field}`);
+    }
+    return paths;
+}
+export function createLogger(config, 
+// Test-only: inject an in-memory destination to assert on real output. When
+// omitted (production), logs go to stderr (+ optional file) via a transport.
+// Redaction is configured on the pino instance itself, so it applies to any
+// destination — tests that drive this function exercise the real mask config.
+destination) {
+    const options = {
+        level: config.logLevel,
+        redact: {
+            paths: redactPaths(),
+            censor: MASK_VALUE,
+        },
+        timestamp: pino.stdTimeFunctions.isoTime,
+    };
+    if (destination) {
+        return pino(options, destination);
+    }
+    const targets = [];
+    // Always log to stderr so stdout stays clean for MCP stdio transport
+    targets.push({
+        target: "pino/file",
+        options: { destination: 2 }, // fd 2 = stderr
+        level: config.logLevel,
+    });
+    // Optional file output
+    if (config.logFile) {
+        targets.push({
+            target: "pino/file",
+            options: { destination: config.logFile },
+            level: config.logLevel,
+        });
+    }
+    return pino(options, pino.transport({ targets }));
+}
+//# sourceMappingURL=logger.js.map

package/dist/prompts/index.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerAllPrompts(server: McpServer): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/prompts/index.js

@@ -0,0 +1,141 @@
+import { z } from "zod";
+function userMessage(text) {
+    return {
+        messages: [{ role: "user", content: { type: "text", text } }],
+    };
+}
+export function registerAllPrompts(server) {
+    // ── tm1_orientation ─────────────────────────────────────────────────
+    // R2-19: LLM onboarding. Surfaces server topology, naming conventions,
+    // pagination/envelope shape, and a workflow→tool map so the agent
+    // doesn't have to re-derive these from individual tool descriptions.
+    server.registerPrompt("tm1_orientation", {
+        title: "TM1 MCP server orientation",
+        description: "Use at the start of a TM1 session to brief yourself on server topology, naming conventions ('}'-prefix control objects), pagination envelope shape, and the recommended tool sequence per workflow (audit, build, debug, deploy). Read before making tool calls in an unfamiliar TM1 environment.",
+    }, () => userMessage([
+        "# TM1 MCP Server Orientation",
+        "",
+        "## Server topology",
+        "TM1 = OLAP database with these primary object types:",
+        "- **Cubes** — multidimensional fact tables. Each dimension is an ordered axis.",
+        "- **Dimensions** — categorical axes with one or more **Hierarchies** (parent/child trees of **Elements**). Element types: N (numeric leaf), C (consolidation/sum), S (string).",
+        "- **Subsets** — named element selections inside a hierarchy. Used as view slicers.",
+        "- **Views** — saved MDX query (rows × columns × titles) over a cube.",
+        "- **Processes (TI)** — TurboIntegrator scripts. 4 tabs: Prolog → Metadata → Data → Epilog.",
+        "- **Chores** — scheduled TI sequences with parameters.",
+        "- **Cube Rules** — calculated cell formulas with SKIPCHECK + FEEDERS.",
+        "- **Clients / Groups** — security principals.",
+        "",
+        "## Naming conventions",
+        "- Object names starting with `}` are **control objects** (system-internal: }ClientProperties, }StatsByCube, …). All `list_*` tools exclude them by default; set `includeControl=true` to inspect.",
+        "- Names are case-sensitive. Use exact match from `list_*` output; never guess casing.",
+        "- TI process names allow dots, slashes, spaces — URI-encoded on the wire.",
+        "",
+        "## Response envelope",
+        "List/search tools return:",
+        "```json",
+        '{ "total": N, "count": K, "offset": O, "has_more": bool, "next_offset": O+K|null, "items": [...] }',
+        "```",
+        'Override with `fetchAll=true` (entire dataset, beware on large dims) or `format="markdown"` (human-readable table, structuredContent still attached).',
+        "",
+        "## Workflow → tool map",
+        "| Goal | Sequence |",
+        "|---|---|",
+        "| Inspect a cube | `tm1_list_cubes(nameExact=X)` → `tm1_get_cube_rules` → `tm1_get_cube_stats` |",
+        "| Debug failed TI | use the `tm1_diagnose_process` prompt |",
+        "| Build new model | `tm1_create_dimension` → `tm1_create_element` (bulk: `tm1_bulk_upsert_elements`) → `tm1_create_cube` |",
+        "| Audit cube | use the `tm1_audit_cube` prompt |",
+        "| Health check | use the `tm1_health_check` prompt |",
+        "| Review rules | use the `tm1_rules_review` prompt |",
+        "| Deploy TI bundle | `tm1_diff_process_with_file` (preview) → `tm1_install_pro_bundle` |",
+        "| Find dead code | `tm1_find_orphan_dimensions`, `tm1_analyze_object_usage` |",
+        "| Pre-write check | `tm1_check_writable_coords` (N-Level + rule-overlap warn) |",
+        "",
+        "## Safety rules",
+        "- Destructive tools (`tm1_delete_cube`, `tm1_delete_dimension`, `tm1_delete_process`, `tm1_clear_cube`) require a `confirm=<name verbatim>` arg as a safety net.",
+        "- `tm1_execute_process` and `tm1_execute_chore` are destructive in effect (irreversible cell mutation) even though they are not `delete_*`.",
+        "- Cube rules edits: validate first with `tm1_check_cube_rule` before `tm1_set_cube_rules`.",
+        "",
+        "## When in doubt",
+        "Call `tm1_get_server_info` first to check version (v11/v12) and feature flags (MTQ, JobQueuing, AllowSeparateNandCRules).",
+    ].join("\n")));
+    // ── tm1_diagnose_process ────────────────────────────────────────────
+    server.registerPrompt("tm1_diagnose_process", {
+        title: "Diagnose failed TI process",
+        description: "Walk-through to root-cause a failed TurboIntegrator process: error logs (with cascade), parameter shape, callgraph dependencies, message log correlation.",
+        argsSchema: {
+            processName: z
+                .string()
+                .describe("Name of the failed TI process to diagnose"),
+        },
+    }, ({ processName }) => userMessage([
+        `Diagnose why TI process **${processName}** failed. Follow this sequence:`,
+        "",
+        `1. **Error logs**: call \`tm1_diagnose_process_error(processName="${processName}", includeRelated=true, tail=80)\` — pulls newest logs + cascade siblings (sub-processes failing seconds apart).`,
+        `2. **Parameters**: call \`tm1_get_process_parameters(processName="${processName}")\` — verify the call site passed the right shape.`,
+        `3. **Source code**: call \`tm1_get_process_code(processName="${processName}")\` to inspect Prolog/Metadata/Data/Epilog.`,
+        `4. **Static refs**: call \`tm1_validate_process_refs(processName="${processName}")\` — surfaces unresolved cube/dimension references.`,
+        `5. **Callgraph**: call \`tm1_analyze_callgraph(processName="${processName}", summary=true)\` — what does this process call, what calls it.`,
+        `6. **Server log** (v11 only): \`tm1_get_message_log(filter="${processName}", top=50)\` for server-side correlation. Skip on v12 — the message log endpoint is deprecated there and the tool is not registered.`,
+        "",
+        "Synthesize: which step failed (Prolog/Metadata/Data/Epilog), what parameter or data triggered it, and the minimal fix.",
+    ].join("\n")));
+    // ── tm1_audit_cube ──────────────────────────────────────────────────
+    server.registerPrompt("tm1_audit_cube", {
+        title: "Audit a cube",
+        description: "Comprehensive read-only audit of a TM1 cube: dimensions, rules, feeders, populated cell counts, callgraph dependencies, recent transaction-log activity.",
+        argsSchema: {
+            cubeName: z.string().describe("Name of the TM1 cube to audit"),
+        },
+    }, ({ cubeName }) => userMessage([
+        `Run a read-only audit of cube **${cubeName}**. Report findings.`,
+        "",
+        `1. **Shape**: \`tm1_list_cubes(nameExact="${cubeName}", includeRules=true)\` — confirm dimensions and rules-presence.`,
+        `2. **Rules**: \`tm1_get_cube_rules(cube="${cubeName}")\` — inspect SKIPCHECK + FEEDERS structure. Validate with \`tm1_check_cube_rule\` if anything looks off.`,
+        `3. **Stats**: \`tm1_get_cube_stats(cubeName="${cubeName}")\` — memory, populated cells, fed cells, feeder efficiency.`,
+        `4. **Object usage**: \`tm1_analyze_object_usage(objectType="cube", objectName="${cubeName}")\` — which TI processes / chores / views reference this cube.`,
+        `5. **Recent writes** (v11 only): \`tm1_get_transaction_log(cubeName="${cubeName}", top=30)\` — what changed lately. Skip on v12 — the transaction log endpoint is deprecated there and the tool is not registered.`,
+        "",
+        "Output: 1-paragraph health summary, list of concerns (high feeder count, rules without skipcheck, orphan deps), and concrete next-action suggestions.",
+    ].join("\n")));
+    // ── tm1_health_check ────────────────────────────────────────────────
+    server.registerPrompt("tm1_health_check", {
+        title: "TM1 server health check",
+        description: "Snapshot of TM1 server state: connection, version, capability flags, object counts, active sessions, recent errors.",
+    }, () => userMessage([
+        "Run a TM1 server health check and report a 1-paragraph summary plus a punch-list of concerns.",
+        "",
+        "1. **State**: `tm1_get_server_state` — connection, version, MTQ/JobQueuing flags, object counts.",
+        "2. **Sessions**: `tm1_list_sessions(compact=true)` — named users vs. anonymous count.",
+        "3. **Threads**: `tm1_list_threads` — long-running operations, locks.",
+        "4. **Recent errors**: `tm1_list_error_logs(top=20)` — newest TI failures.",
+        "5. **Server log** (v11 only): `tm1_get_message_log(top=50)` — recent server-level events. Skip on v12, where the tool is not registered.",
+        "",
+        'Flag: stuck threads (state="Wait" with elapsedTime > 10min), repeated error patterns, capability-flag surprises.',
+    ].join("\n")));
+    // ── tm1_rules_review ────────────────────────────────────────────────
+    server.registerPrompt("tm1_rules_review", {
+        title: "Cube rules review",
+        description: "Code-review a cube's rules text: SKIPCHECK placement, FEEDERS coverage, ratio consolidations (N/C splits), syntax validation.",
+        argsSchema: {
+            cubeName: z.string().describe("Name of the cube whose rules to review"),
+        },
+    }, ({ cubeName }) => userMessage([
+        `Review the rules of cube **${cubeName}**. Code-review style.`,
+        "",
+        `1. **Read rules**: \`tm1_get_cube_rules(cube="${cubeName}")\` — full rules text.`,
+        `2. **Syntax check**: \`tm1_check_cube_rule(cube="${cubeName}", rules=<text from step 1>)\` — surface line-numbered errors before any change.`,
+        `3. **Stats correlation**: \`tm1_get_cube_stats(cubeName="${cubeName}")\` — fed-cell-count vs populated-numeric, feeder efficiency.`,
+        `4. **Reference impact**: \`tm1_analyze_object_usage(objectType="cube", objectName="${cubeName}")\` — what depends on this cube's calculated cells.`,
+        `5. **Per-cell verification (v11)**: pick a populated rule cell via \`tm1_sample_cells(cubeName="${cubeName}")\`, then \`tm1_trace_cell_calculation\` (why has it this value) and \`tm1_check_feeders\` / \`tm1_trace_feeders\` (does it feed correctly) to confirm suspected feeder findings at runtime.`,
+        "",
+        "Comment on:",
+        "- SKIPCHECK at the top, FEEDERS section structure",
+        "- ratio measures with explicit N: + C: branches (consolidations should not sum ratios)",
+        "- feeder coverage for every rules-fed cell",
+        "- AllowSeparateNandCRules expectations (check via tm1_get_server_info)",
+        "",
+        "Suggest changes as a unified diff.",
+    ].join("\n")));
+}
+//# sourceMappingURL=index.js.map