@heuresis/mcp 1.0.0-rc.16 → 1.0.0-rc.18

package/dist/cloudClient.js

@@ -155,3 +155,15 @@ export function unwrap(res) {
         throw new Error('Empty result from cloud.');
     return res.data;
 }
+/**
+ * Like unwrap(), but a `null` data is RETURNED rather than thrown. Use for
+ * `.maybeSingle()` lookups where "no row" is a meaningful outcome the caller
+ * handles itself (e.g. `if (!node) return { error: 'No concept with id …' }`).
+ * Wrapping those in unwrap() turned a legitimate not-found into the opaque
+ * "Empty result from cloud" — and made get_concept throw on dangling ancestry.
+ */
+export function unwrapMaybe(res) {
+    if (res.error)
+        throw new Error(res.error.message);
+    return res.data;
+}

package/dist/cloudTools.js

@@ -41,7 +41,7 @@
 // the change. The stamp is best-effort: a failed provenance insert never
 // fails the underlying write.
 import { z } from 'zod';
-import { unwrap } from './cloudClient.js';
+import { unwrap, unwrapMaybe } from './cloudClient.js';
 // ---------------------------------------------------------------------------
 // Shared helpers
 // ---------------------------------------------------------------------------
@@ -188,11 +188,25 @@ function shapeProject(p) {
 // ---------------------------------------------------------------------------
 export const getSubtreeInput = z
     .object({
-    rootId: z.string(),
+    rootId: z.string().min(1).optional(),
+    id: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Alias for rootId — the concept to root the subtree at (use either).'),
     depth: z.number().int().min(0).max(6).default(3),
     detail: detailArg,
 })
-    .strict();
+    .strict()
+    .refine((a) => Boolean(a.rootId ?? a.id), {
+    message: 'Provide `id` (or `rootId`) — the concept to get the subtree for.',
+    path: ['id'],
+})
+    .transform((a) => ({
+    rootId: (a.rootId ?? a.id),
+    depth: a.depth,
+    detail: a.detail,
+}));
 export async function getSubtree(client, args) {
     const rootRes = await client.from('nodes').select('*').eq('id', args.rootId).maybeSingle();
     if (rootRes.error)
@@ -280,7 +294,7 @@ export async function getConcept(client, args) {
         let cur = node.parent_id;
         while (cur && !seen.has(cur)) {
             seen.add(cur);
-            const p = unwrap(await client.from('nodes').select('id, label, parent_id').eq('id', cur).maybeSingle());
+            const p = unwrapMaybe(await client.from('nodes').select('id, label, parent_id').eq('id', cur).maybeSingle());
             if (!p)
                 break;
             chain.unshift({ id: p.id, label: p.label });
@@ -417,7 +431,7 @@ export async function addConcept(client, args) {
     // Figure out parent + project.
     let parentNode = null;
     if (typeof args.parentId === 'string') {
-        parentNode = unwrap(await client.from('nodes').select('*').eq('id', args.parentId).maybeSingle());
+        parentNode = unwrapMaybe(await client.from('nodes').select('*').eq('id', args.parentId).maybeSingle());
         if (!parentNode)
             return { error: `Parent ${args.parentId} not found.` };
     }
@@ -768,6 +782,12 @@ export const listConceptsInput = z
     includeArchived: z.boolean().default(false),
     detail: detailArg,
     limit: z.number().int().min(1).max(500).default(500),
+    offset: z
+        .number()
+        .int()
+        .min(0)
+        .default(0)
+        .describe('Skip this many results — page through a large workspace with limit + offset.'),
 })
     .strict();
 export async function listConcepts(client, args) {
@@ -778,7 +798,7 @@ export async function listConcepts(client, args) {
         if (!args.projectId) {
             return { error: 'scope=project requires projectId.' };
         }
-        const proj = unwrap(await client
+        const proj = unwrapMaybe(await client
             .from('projects')
             .select('id, name')
             .eq('id', args.projectId)
@@ -803,20 +823,26 @@ export async function listConcepts(client, args) {
     }
     let qb = client
         .from('nodes')
-        .select('*')
+        .select('*', { count: 'exact' })
         .eq('workspace_id', wsId)
         .order('updated_at', { ascending: false })
-        .limit(args.limit);
+        .range(args.offset, args.offset + args.limit - 1);
     if (memberIds)
         qb = qb.in('id', memberIds);
     if (!args.includeArchived)
         qb = qb.neq('status', 'archived');
-    const rows = unwrap(await qb);
+    const res = await qb;
+    if (res.error)
+        throw new Error(res.error.message);
+    const rows = (res.data ?? []);
+    const total = res.count ?? rows.length;
     return {
         scope: args.scope,
         projectName,
-        total: rows.length,
-        truncated: rows.length === args.limit,
+        total,
+        offset: args.offset,
+        returned: rows.length,
+        hasMore: args.offset + rows.length < total,
         concepts: rows.map((n) => nodeView(n, args.detail)),
     };
 }
@@ -912,13 +938,13 @@ export const validateConceptInput = z
 })
     .strict();
 export async function validateConcept(client, args) {
-    const node = unwrap(await client.from('nodes').select('*').eq('id', args.id).maybeSingle());
+    const node = unwrapMaybe(await client.from('nodes').select('*').eq('id', args.id).maybeSingle());
     if (!node)
         return { error: `No concept with id ${args.id}` };
     const patch = { status: 'validated' };
     if (args.rationale !== undefined)
         patch.rationale = args.rationale;
-    const row = unwrap(await client
+    const row = unwrapMaybe(await client
         .from('nodes')
         .update(patch)
         .eq('id', args.id)
@@ -944,7 +970,7 @@ export const setStandingInput = z
 })
     .strict();
 export async function setStanding(client, args) {
-    const node = unwrap(await client
+    const node = unwrapMaybe(await client
         .from('nodes')
         .select('id, workspace_id, label, standing_rationale')
         .eq('id', args.id)
@@ -956,7 +982,7 @@ export async function setStanding(client, args) {
         standing_rationale: args.rationale,
         standing_assessed_at: new Date().toISOString(),
     };
-    const row = unwrap(await client
+    const row = unwrapMaybe(await client
         .from('nodes')
         .update(patch)
         .eq('id', args.id)
@@ -981,7 +1007,7 @@ export async function setStanding(client, args) {
 // ---------------------------------------------------------------------------
 export const archiveConceptInput = z.object({ id: z.string().min(1) }).strict();
 export async function archiveConcept(client, args) {
-    const node = unwrap(await client
+    const node = unwrapMaybe(await client
         .from('nodes')
         .select('id, workspace_id, label, status')
         .eq('id', args.id)
@@ -991,7 +1017,7 @@ export async function archiveConcept(client, args) {
     if (node.status === 'archived') {
         return { id: node.id, label: node.label, status: node.status, noop: true };
     }
-    const row = unwrap(await client
+    const row = unwrapMaybe(await client
         .from('nodes')
         .update({ status: 'archived' })
         .eq('id', args.id)
@@ -1008,7 +1034,7 @@ export async function archiveConcept(client, args) {
 }
 export const unarchiveConceptInput = z.object({ id: z.string().min(1) }).strict();
 export async function unarchiveConcept(client, args) {
-    const node = unwrap(await client
+    const node = unwrapMaybe(await client
         .from('nodes')
         .select('id, workspace_id, label, status')
         .eq('id', args.id)
@@ -1018,7 +1044,7 @@ export async function unarchiveConcept(client, args) {
     if (node.status !== 'archived') {
         return { id: node.id, label: node.label, status: node.status, noop: true };
     }
-    const row = unwrap(await client
+    const row = unwrapMaybe(await client
         .from('nodes')
         .update({ status: 'open' })
         .eq('id', args.id)
@@ -1035,7 +1061,7 @@ export async function unarchiveConcept(client, args) {
 }
 export const starConceptInput = z.object({ id: z.string().min(1) }).strict();
 export async function starConcept(client, args) {
-    const node = unwrap(await client
+    const node = unwrapMaybe(await client
         .from('nodes')
         .select('id, workspace_id, label, starred')
         .eq('id', args.id)
@@ -1043,7 +1069,7 @@ export async function starConcept(client, args) {
     if (!node)
         return { error: `No concept with id ${args.id}` };
     const next = !node.starred;
-    const row = unwrap(await client
+    const row = unwrapMaybe(await client
         .from('nodes')
         .update({ starred: next })
         .eq('id', args.id)
@@ -1070,7 +1096,7 @@ export async function starConcept(client, args) {
 // in code, collect every descendant, and delete the bottom-up set.
 export const removeConceptInput = z.object({ id: z.string().min(1) }).strict();
 export async function removeConcept(client, args) {
-    const node = unwrap(await client
+    const node = unwrapMaybe(await client
         .from('nodes')
         .select('id, workspace_id, label')
         .eq('id', args.id)
@@ -1086,26 +1112,40 @@ export async function removeConcept(client, args) {
     if (isRoot.length > 0) {
         return { error: 'Cannot delete a project root node.' };
     }
-    // Walk the parent_id subtree in memory (cheaper than depth round-trips).
-    const allNodes = unwrap(await client
-        .from('nodes')
-        .select('id, parent_id')
-        .eq('workspace_id', node.workspace_id));
+    // Walk the subtree via BOTH parent_id AND partition edges. A child can be
+    // attached either way; walking parent_id alone would strand partition-only
+    // children as dangling orphans (the inconsistency surfaced in the rc.17
+    // review — get_subtree counts partition-edge children, so the cascade must
+    // too).
+    const allNodes = unwrap(await client.from('nodes').select('id, parent_id').eq('workspace_id', node.workspace_id));
+    const partEdges = unwrap(await client
+        .from('edges')
+        .select('from_id, to_id')
+        .eq('workspace_id', node.workspace_id)
+        .eq('kind', 'partition'));
     const childrenByParent = new Map();
-    for (const n of allNodes) {
-        if (n.parent_id) {
-            const arr = childrenByParent.get(n.parent_id) ?? [];
-            arr.push(n.id);
-            childrenByParent.set(n.parent_id, arr);
-        }
-    }
+    const addChild = (parent, child) => {
+        const arr = childrenByParent.get(parent) ?? [];
+        arr.push(child);
+        childrenByParent.set(parent, arr);
+    };
+    for (const n of allNodes)
+        if (n.parent_id)
+            addChild(n.parent_id, n.id);
+    for (const e of partEdges)
+        addChild(e.from_id, e.to_id);
     const toDelete = [];
+    const seen = new Set();
     const stack = [args.id];
     while (stack.length > 0) {
         const cur = stack.pop();
+        if (seen.has(cur))
+            continue;
+        seen.add(cur);
         toDelete.push(cur);
-        const kids = childrenByParent.get(cur) ?? [];
-        stack.push(...kids);
+        for (const k of childrenByParent.get(cur) ?? [])
+            if (!seen.has(k))
+                stack.push(k);
     }
     // Delete in one shot — edges/junctions cascade via FK; provenance
     // cascades via FK in 0015's table definition.
@@ -1119,6 +1159,40 @@ export async function removeConcept(client, args) {
     };
 }
 // ---------------------------------------------------------------------------
+// remove_concepts (bulk) — delete many concepts in one call.
+// ---------------------------------------------------------------------------
+// Sequential (not parallel) so a big cleanup can't hammer the backend; each id
+// reuses removeConcept (so each cascades its own subtree). Per-id results are
+// returned so the caller sees exactly what landed — ids already gone (e.g.
+// swept up in another id's cascade) come back ok:false with a not-found error,
+// which is expected, not fatal.
+export const removeConceptsInput = z
+    .object({
+    ids: z
+        .array(z.string().min(1))
+        .min(1)
+        .max(500)
+        .describe('Concept ids to hard-delete. Each cascades its own subtree.'),
+})
+    .strict();
+export async function removeConcepts(client, args) {
+    const results = [];
+    for (const id of args.ids) {
+        const r = (await removeConcept(client, { id }));
+        if (r.error)
+            results.push({ id, ok: false, error: r.error });
+        else
+            results.push({ id, ok: true, cascadeCount: r.cascadeCount });
+    }
+    const ok = results.filter((r) => r.ok).length;
+    return {
+        requested: args.ids.length,
+        deleted: ok,
+        failed: args.ids.length - ok,
+        results,
+    };
+}
+// ---------------------------------------------------------------------------
 // bulk_add_concepts (atomic via fn_bulk_add_concepts RPC)
 // ---------------------------------------------------------------------------
 // Each child resolves its project_id either explicitly (via the item's
@@ -1210,7 +1284,7 @@ export const setParentInput = z
 })
     .strict();
 export async function setParent(client, args) {
-    const node = unwrap(await client
+    const node = unwrapMaybe(await client
         .from('nodes')
         .select('id, workspace_id, parent_id, label')
         .eq('id', args.nodeId)
@@ -1222,7 +1296,7 @@ export async function setParent(client, args) {
     }
     let resolvedParentId = args.newParentId;
     if (resolvedParentId) {
-        const parent = unwrap(await client
+        const parent = unwrapMaybe(await client
             .from('nodes')
             .select('id, workspace_id')
             .eq('id', resolvedParentId)
@@ -1232,6 +1306,22 @@ export async function setParent(client, args) {
         if (parent.workspace_id !== node.workspace_id) {
             return { error: 'Cannot re-parent across workspaces.' };
         }
+        // Cycle guard: the new parent must not sit inside this node's own subtree —
+        // that would detach the subtree from any root and break parent-chain
+        // traversal (get_subtree / get_concept ancestry / remove_concept cascade).
+        const wsNodes = unwrap(await client.from('nodes').select('id, parent_id').eq('workspace_id', node.workspace_id));
+        const parentOf = new Map(wsNodes.map((n) => [n.id, n.parent_id]));
+        let walk = resolvedParentId;
+        const visited = new Set();
+        while (walk && !visited.has(walk)) {
+            if (walk === args.nodeId) {
+                return {
+                    error: "Cannot set parent: the target parent is inside this node's own subtree (would create a cycle).",
+                };
+            }
+            visited.add(walk);
+            walk = parentOf.get(walk) ?? null;
+        }
     }
     // 1) Update parent_id.
     const updRes = await client
@@ -1531,13 +1621,101 @@ export async function updateProject(client, args) {
         lifecycle: row.lifecycle,
     };
 }
-export const deleteProjectInput = z.object({ id: z.string().min(1) }).strict();
+export const deleteProjectInput = z
+    .object({
+    id: z.string().min(1),
+    deleteNodes: z
+        .boolean()
+        .default(false)
+        .describe("Also hard-delete every concept in this project (each cascades its subtree). Default false leaves the nodes behind as orphans — matching prior behavior. Use true to avoid creating orphans."),
+})
+    .strict();
 export async function deleteProject(client, args) {
+    if (args.deleteNodes) {
+        // Capture members BEFORE deleting the project (project_nodes cascades away
+        // with it). Delete the project first so removeConcept's "can't delete a
+        // project root" guard no longer blocks the root node.
+        const members = unwrap(await client.from('project_nodes').select('node_id').eq('project_id', args.id));
+        const del = await client.from('projects').delete().eq('id', args.id);
+        if (del.error)
+            return { error: del.error.message };
+        let nodesDeleted = 0;
+        for (const m of members) {
+            const r = (await removeConcept(client, { id: m.node_id }));
+            // Many members are already gone (swept up in the root's cascade); that
+            // returns a not-found error we simply skip.
+            if (!r.error && typeof r.cascadeCount === 'number')
+                nodesDeleted += r.cascadeCount;
+        }
+        return { id: args.id, deleted: true, nodesDeleted };
+    }
     const del = await client.from('projects').delete().eq('id', args.id);
     if (del.error)
         return { error: del.error.message };
     return { id: args.id, deleted: true };
 }
+// ---------------------------------------------------------------------------
+// find_orphans — surface concepts that no normal traversal reaches.
+// ---------------------------------------------------------------------------
+// Two integrity classes, both confined to the caller's own workspace (RLS):
+//   • projectless  — node in no project (the classic residue of delete_project,
+//                    which leaves nodes behind).
+//   • danglingParent — node whose parent_id points at a row that no longer
+//                    exists (invisible to root traversal, yet still present).
+// Read-only; pair with remove_concepts (to delete) or set_parent (to re-home).
+export const findOrphansInput = z
+    .object({
+    kind: z
+        .enum(['projectless', 'dangling', 'all'])
+        .default('all')
+        .describe("Which orphan class to surface: 'projectless', 'dangling', or 'all'."),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(1000)
+        .default(200)
+        .describe('Max nodes to list per class (counts are always exact).'),
+})
+    .strict();
+export async function findOrphans(client, args) {
+    const wsId = await resolveWorkspaceId(client);
+    const allNodes = unwrap(await client.from('nodes').select('id, label, parent_id, status').eq('workspace_id', wsId));
+    const liveIds = new Set(allNodes.map((n) => n.id));
+    const projects = unwrap(await client.from('projects').select('id').eq('workspace_id', wsId));
+    let memberIds = new Set();
+    if (projects.length > 0) {
+        const pn = unwrap(await client
+            .from('project_nodes')
+            .select('node_id')
+            .in('project_id', projects.map((p) => p.id)));
+        memberIds = new Set(pn.map((r) => r.node_id));
+    }
+    const view = (n) => ({
+        id: n.id,
+        label: n.label,
+        parentId: n.parent_id,
+        status: n.status,
+    });
+    const result = { workspaceId: wsId, totalNodes: allNodes.length };
+    if (args.kind === 'projectless' || args.kind === 'all') {
+        const projectless = allNodes.filter((n) => !memberIds.has(n.id));
+        result.projectless = {
+            count: projectless.length,
+            nodes: projectless.slice(0, args.limit).map(view),
+        };
+    }
+    if (args.kind === 'dangling' || args.kind === 'all') {
+        const dangling = allNodes.filter((n) => n.parent_id && !liveIds.has(n.parent_id));
+        result.danglingParent = {
+            count: dangling.length,
+            nodes: dangling.slice(0, args.limit).map(view),
+        };
+    }
+    result.note =
+        'projectless = in no project (often left by delete_project). danglingParent = parent_id points at a deleted node. To clean up: remove_concepts(ids) to delete, or set_parent to re-home.';
+    return result;
+}
 export const CLOUD_TOOLS = [
     // ── Reads ──────────────────────────────────────────────────────────────
     {
@@ -1554,7 +1732,9 @@ export const CLOUD_TOOLS = [
     },
     {
         name: 'get_subtree',
-        description: 'A node and its descendants up to a given depth. Use when the user asks "tell me about everything under X".',
+        description: 'A node and its descendants up to a given depth. Pass the concept as `id` (or `rootId`). Use when the user asks "tell me about everything under X".',
+        // ZodEffects (refine+transform for the id/rootId alias) — cast like the
+        // operator tools; zodToJsonSchema unwraps it for the served schema.
         inputSchema: getSubtreeInput,
         handler: async (client, args) => getSubtree(client, getSubtreeInput.parse(args)),
     },
@@ -1657,10 +1837,22 @@ export const CLOUD_TOOLS = [
     },
     {
         name: 'remove_concept',
-        description: 'Hard-delete a concept and its descendants (walks the parent_id subtree). Edges and project/idea memberships cascade via FK. Refuses to delete a project root node.',
+        description: 'Hard-delete a concept and its descendants (walks the subtree via parent_id AND partition edges). Edges and project/idea memberships cascade via FK. Refuses to delete a project root node. For many at once, use remove_concepts.',
         inputSchema: removeConceptInput,
         handler: async (client, args) => removeConcept(client, removeConceptInput.parse(args)),
     },
+    {
+        name: 'remove_concepts',
+        description: "Bulk hard-delete: delete many concepts in one call (each cascades its own subtree). Returns per-id results. Ids already swept up in another id's cascade come back ok:false (not-found) — expected, not fatal. Pair with find_orphans for cleanup.",
+        inputSchema: removeConceptsInput,
+        handler: async (client, args) => removeConcepts(client, removeConceptsInput.parse(args)),
+    },
+    {
+        name: 'find_orphans',
+        description: "Surface concepts no normal traversal reaches, scoped to your workspace: 'projectless' (in no project — typically left behind by delete_project) and 'danglingParent' (parent_id points at a deleted node). Read-only. Clean up with remove_concepts (delete) or set_parent (re-home).",
+        inputSchema: findOrphansInput,
+        handler: async (client, args) => findOrphans(client, findOrphansInput.parse(args)),
+    },
     {
         name: 'bulk_add_concepts',
         description: 'Create many concepts in a single atomic transaction. `items` is an array; each item carries label / description? / parentId? / projectId? / tags?. project_id is resolved per-item (explicit > inherited from parent > workspace solo project). Returns the created ids in input order.',
@@ -1725,7 +1917,7 @@ export const CLOUD_TOOLS = [
     },
     {
         name: 'delete_project',
-        description: "Delete a project. Project_nodes / problem_frames / closed_worlds / lab_matrix_cells cascade via FK. Concepts that belonged to ONLY this project are orphaned (project_id → NULL) — they are NOT auto-deleted.",
+        description: 'Delete a project. By default its concepts are LEFT behind as orphans (find them later with find_orphans). Pass deleteNodes:true to also hard-delete every concept in the project (each cascades its subtree) so no orphans are created.',
         inputSchema: deleteProjectInput,
         handler: async (client, args) => deleteProject(client, deleteProjectInput.parse(args)),
     },

package/dist/index.js

@@ -14,7 +14,7 @@
 //
 // Subcommands (one-shot, never start the MCP server):
 //   login | logout | whoami | --help
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
@@ -27,8 +27,87 @@ import { CloudAuthError, getCloudClient, getCloudClientFromPassword } from './cl
 import { ensureProxyAgent } from './proxy.js';
 import { DEFAULT_SUPABASE_URL, helpCommand, loginCommand, logoutCommand, whoamiCommand, } from './cli.js';
 import { readRealtimeFlag, resolveSubscriptionWorkspaceId, startRealtimeSubscription, stripRealtimeFlags, } from './realtime.js';
-const VERSION = '0.2.0-alpha';
+// Report the real published version (dist/index.js → ../package.json) so
+// `heuresis-mcp --version` and the startup banner never lie about what's loaded.
+const VERSION = (() => {
+    try {
+        const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+        return pkg.version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+})();
 const MAX_RESULT_CHARS = 50_000;
+// Fields worth preserving when a node/edge-bearing result is degraded to fit
+// the size cap (everything else — descriptions, rationale, tags — is dropped).
+const SKELETON_KEYS = [
+    'id',
+    'label',
+    'name',
+    'parentId',
+    'parent_id',
+    'kind',
+    'from',
+    'to',
+    'status',
+    'standing',
+    'starred',
+    'projectId',
+    'rootNodeId',
+];
+function skeletonize(item) {
+    if (item && typeof item === 'object' && !Array.isArray(item)) {
+        const o = item;
+        const keep = {};
+        for (const k of SKELETON_KEYS)
+            if (k in o)
+                keep[k] = o[k];
+        return Object.keys(keep).length > 0 ? keep : item;
+    }
+    return item;
+}
+// Never hard-fail a read on size. If a result blows the cap, first drop verbose
+// fields from its array elements (keep id/label/parent/kind…), then, if still
+// too big, slice the largest array — always tagging `_truncated` + `_note` so
+// the agent knows to narrow (limit/depth/scope) or fetch detail via get_concept.
+function fitResultToCap(result, cap) {
+    if (JSON.stringify(result, null, 2).length <= cap)
+        return result;
+    if (!result || typeof result !== 'object' || Array.isArray(result)) {
+        const s = JSON.stringify(result, null, 2);
+        return {
+            _truncated: true,
+            _note: `Result exceeded ${cap} chars and could not be structurally reduced; showing a prefix. Narrow the query.`,
+            preview: s.slice(0, Math.max(0, cap - 200)),
+        };
+    }
+    const obj = { ...result };
+    const arrayKeys = Object.keys(obj).filter((k) => Array.isArray(obj[k]) && obj[k].some((x) => x && typeof x === 'object'));
+    for (const k of arrayKeys)
+        obj[k] = obj[k].map(skeletonize);
+    obj._truncated = true;
+    obj._note =
+        'Result exceeded the size cap; verbose fields were dropped (id/label/parent/kind kept). Use get_concept(id) for full detail, or narrow with limit/depth/scope.';
+    let guard = 0;
+    while (JSON.stringify(obj, null, 2).length > cap && guard++ < 100) {
+        let biggestKey;
+        let biggestLen = 0;
+        for (const k of arrayKeys) {
+            const len = obj[k].length;
+            if (len > biggestLen) {
+                biggestLen = len;
+                biggestKey = k;
+            }
+        }
+        if (!biggestKey || biggestLen <= 1)
+            break;
+        const arr = obj[biggestKey];
+        obj[biggestKey] = arr.slice(0, Math.max(1, Math.floor(arr.length * 0.8)));
+        obj._note = `Result exceeded the size cap; showing a truncated, skeletonized view (some "${biggestKey}" omitted). Narrow with limit/depth/scope, or fetch specifics with get_concept.`;
+    }
+    return obj;
+}
 function makeCloudTools(getClient, operatorTools) {
     // Lazy: defer the actual auth handshake until the first tool call so the
     // MCP server boots fast.
@@ -252,20 +331,10 @@ async function runServer() {
             // background with their own concurrency control (cloudOperators.ts), so no
             // per-call serialization is needed here.
             const result = await tool.handler(req.params.arguments ?? {});
-            const text = JSON.stringify(result, null, 2);
-            if (text.length > MAX_RESULT_CHARS) {
-                return {
-                    isError: true,
-                    content: [
-                        {
-                            type: 'text',
-                            text: `Result too large (${text.length} chars, limit ${MAX_RESULT_CHARS}). ` +
-                                `Narrow the query: lower 'limit'/'depth', keep detail='compact', ` +
-                                `or fetch individual nodes with get_concept.`,
-                        },
-                    ],
-                };
-            }
+            // Never hard-fail on size: auto-degrade node/edge-bearing results
+            // (skeletonize → slice) so the agent always gets actionable structure
+            // back instead of an error it has to recover from.
+            const text = JSON.stringify(fitResultToCap(result, MAX_RESULT_CHARS), null, 2);
             return {
                 content: [{ type: 'text', text }],
             };
@@ -358,6 +427,11 @@ async function main() {
         case 'whoami':
             await whoamiCommand();
             return;
+        case '-v':
+        case '--version':
+        case 'version':
+            console.log(VERSION);
+            return;
         case '-h':
         case '--help':
         case 'help':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heuresis/mcp",
-  "version": "1.0.0-rc.16",
+  "version": "1.0.0-rc.18",
   "mcpName": "io.github.ToremLabs/heuresis",
   "description": "Cloud-authenticated Model Context Protocol server for a Heuresis workspace. Logs into the user's Heuresis account and lets any MCP client (Claude Desktop, Claude Code, Cursor, custom agents) read and write the same workspace the webapp uses. 31 data tools, 3 operator tools (Branch/Matrix/C-K/ASIT/TRIZ/Free/Combine/Explore), and live Realtime change subscriptions.",
   "type": "module",