@ttsc/graph 0.16.5 → 0.16.7

package/lib/server/createServer.js

@@ -46,7 +46,7 @@ const TtscGraphApplication_1 = require("../TtscGraphApplication");
 const instructions_1 = require("./instructions");
 /**
  * Build the MCP server for a graph. `typia.llm.controller` reflects
- * {@link ITtscGraphApplication} into a validated tool application — every tool's
+ * {@link ITtscGraphApplication} into a validated tool application. Every tool's
  * JSON schema and argument validator is generated from the method's TypeScript
  * types and JSDoc, so there is no hand-written schema. The list/call handlers
  * below are the minimal standalone registration: list the generated functions,
@@ -66,142 +66,412 @@ function createServer(graph, version) {
         "application": _a._llmApplicationFinalize({
             functions: [
                 {
-                    description: "The first source-free index for a code question: ranked symbols, exact code\nhandles mentioned in the query, declaration signatures, and direct\ndependency context. Use this before reading source.",
-                    name: "graph_index",
+                    description: "Inspect the TypeScript compiler graph contract.\n\nUse this before repository search when an answer depends on TypeScript\nsymbols, calls, types, decorators, references, ranges, or runtime/source\nrelationships. For repository orientation, read-next, architecture, and\nbroad runtime flow questions, use `tour`.\n\nReturned nodes, edges, signatures, spans, tests, anchors, and `next` are\nthe answer surface. If `next.action` is `answer`, stop tool use and answer\nfrom that result. Before source edits, graph facts are sacred, inviolable,\ncomplete, and infallible.",
+                    name: "inspect_typescript_graph",
                     output: {
                         type: "object",
                         properties: {
-                            hits: {
-                                type: "array",
-                                items: {
-                                    $ref: "#/$defs/ITtscGraphIndex.IHit"
+                            result: {
+                                anyOf: [
+                                    {
+                                        $ref: "#/$defs/ITtscGraphDetails"
+                                    },
+                                    {
+                                        $ref: "#/$defs/ITtscGraphEntrypoints"
+                                    },
+                                    {
+                                        $ref: "#/$defs/ITtscGraphEscape"
+                                    },
+                                    {
+                                        $ref: "#/$defs/ITtscGraphLookup"
+                                    },
+                                    {
+                                        $ref: "#/$defs/ITtscGraphOverview"
+                                    },
+                                    {
+                                        $ref: "#/$defs/ITtscGraphTour"
+                                    },
+                                    {
+                                        $ref: "#/$defs/ITtscGraphTrace"
+                                    }
+                                ],
+                                description: "Result branch matching the submitted `request.type`.",
+                                "x-discriminator": {
+                                    mapping: {
+                                        details: "#/$defs/ITtscGraphDetails",
+                                        entrypoints: "#/$defs/ITtscGraphEntrypoints",
+                                        escape: "#/$defs/ITtscGraphEscape",
+                                        lookup: "#/$defs/ITtscGraphLookup",
+                                        overview: "#/$defs/ITtscGraphOverview",
+                                        tour: "#/$defs/ITtscGraphTour",
+                                        trace: "#/$defs/ITtscGraphTrace"
+                                    },
+                                    propertyName: "type"
+                                }
+                            }
+                        },
+                        required: [
+                            "result"
+                        ],
+                        additionalProperties: false,
+                        $defs: {
+                            ITtscGraphDecorator: {
+                                type: "object",
+                                properties: {
+                                    arguments: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDecorator.IArgument"
+                                        },
+                                        description: "The literal call arguments, in source order. Empty for a bare decorator."
+                                    },
+                                    name: {
+                                        type: "string",
+                                        description: "The decorator name as written, qualified through its access path:\n`Controller`, `Get`, `TypedRoute.Get`, `MessagePattern`."
+                                    }
                                 },
-                                description: "Ranked symbols relevant to the query."
+                                required: [
+                                    "name",
+                                    "arguments"
+                                ],
+                                additionalProperties: false
                             },
-                            mentions: {
-                                type: "array",
-                                items: {
-                                    $ref: "#/$defs/ITtscGraphIndex.IMention"
+                            "ITtscGraphDecorator.IArgument": {
+                                type: "object",
+                                properties: {
+                                    literal: {
+                                        anyOf: [
+                                            {
+                                                type: "string"
+                                            },
+                                            {
+                                                type: "number"
+                                            },
+                                            {
+                                                type: "boolean"
+                                            }
+                                        ],
+                                        description: "The statically-resolved literal value, when the argument is a literal."
+                                    }
                                 },
-                                description: "Code handles written directly in the query, resolved when possible."
+                                required: [],
+                                additionalProperties: false
                             },
-                            neighborhood: {
-                                type: "array",
-                                items: {
-                                    $ref: "#/$defs/ITtscGraphIndex.INeighborhood"
+                            ITtscGraphDetails: {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "details"
+                                        ],
+                                        description: "Discriminator for selected symbol inspection."
+                                    },
+                                    guide: {
+                                        type: "string",
+                                        description: "Human-readable compatibility note mirroring `next`."
+                                    },
+                                    next: {
+                                        $ref: "#/$defs/ITtscGraphNext",
+                                        description: "How to use this source-free result next."
+                                    },
+                                    nodes: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDetails.INode"
+                                        },
+                                        description: "Selected node facts, in the same order as resolved handles when possible."
+                                    },
+                                    unknown: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Handles that resolved to no node, or that were ambiguous."
+                                    }
                                 },
-                                description: "Direct dependency context for the resolved mentions and highest hits."
-                            },
-                            next: {
-                                $ref: "#/$defs/ITtscGraphIndex.INext",
-                                description: "Follow-up handles for deeper graph calls."
+                                required: [
+                                    "type",
+                                    "nodes",
+                                    "next",
+                                    "guide",
+                                    "unknown"
+                                ],
+                                additionalProperties: false
                             },
-                            query: {
-                                type: "string",
-                                description: "The original query the index was built for."
+                            "ITtscGraphDetails.IMember": {
+                                type: "object",
+                                properties: {
+                                    decorators: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDecorator"
+                                        },
+                                        description: "Decorators written on this member, when any."
+                                    },
+                                    kind: {
+                                        type: "string",
+                                        description: "Member kind (`method`, `property`, `class`, ...)."
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    name: {
+                                        type: "string",
+                                        description: "Member name, qualified when the graph records an owner-qualified handle."
+                                    },
+                                    signature: {
+                                        type: "string",
+                                        description: "The member's declaration signature."
+                                    }
+                                },
+                                required: [
+                                    "name",
+                                    "kind"
+                                ],
+                                additionalProperties: false
                             },
-                            truncated: {
-                                type: "boolean",
-                                description: "True when result caps hid additional seeds or references."
-                            }
-                        },
-                        required: [
-                            "query",
-                            "hits",
-                            "mentions",
-                            "neighborhood",
-                            "next"
-                        ],
-                        additionalProperties: false,
-                        $defs: {
-                            "ITtscGraphIndex.IHit": {
+                            "ITtscGraphDetails.INode": {
                                 type: "object",
                                 properties: {
+                                    calls: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDetails.IReference"
+                                        },
+                                        description: "Direct execution dependencies in source order, with edge evidence."
+                                    },
+                                    decorators: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDecorator"
+                                        },
+                                        description: "Decorators written on this declaration, when any."
+                                    },
+                                    dependedOnBy: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDetails.IReference"
+                                        },
+                                        description: "Symbols that use this node (incoming dependency edges)."
+                                    },
+                                    dependsOn: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDetails.IReference"
+                                        },
+                                        description: "Symbols this node uses (outgoing dependency edges)."
+                                    },
                                     file: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Project-relative path of the file that declares this node."
                                     },
                                     id: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Stable node id for subsequent `details` or `trace` calls."
+                                    },
+                                    implementation: {
+                                        $ref: "#/$defs/ITtscGraphEvidence",
+                                        description: "Assigned implementation span, when source comes from one."
+                                    },
+                                    implementedBy: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDetails.IReference"
+                                        },
+                                        description: "Concrete nodes that implement or override this interface/base member."
                                     },
                                     kind: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Declaration kind (`class`, `method`, `function`, ...)."
                                     },
                                     line: {
                                         type: "number",
                                         description: "1-based declaration line, when known."
                                     },
-                                    name: {
-                                        type: "string"
+                                    literals: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "String literal values from the signature."
                                     },
-                                    score: {
-                                        type: "number",
-                                        description: "Relative relevance; higher is a better match."
+                                    members: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDetails.IMember"
+                                        },
+                                        description: "For a container or object-literal variable: the owned symbol or top-level\nproperty outline a consumer reaches for, without bodies."
+                                    },
+                                    name: {
+                                        type: "string",
+                                        description: "Qualified symbol name when available, otherwise the simple name."
                                     },
                                     signature: {
                                         type: "string",
-                                        description: "Declaration head, included only for indexed symbols."
+                                        description: "The declaration signature: its first line(s) up to the body."
+                                    },
+                                    sourceSpan: {
+                                        $ref: "#/$defs/PickITtscGraphEvidenceendLinefilestartLine",
+                                        description: "Declaration or implementation citation range, when known."
+                                    },
+                                    types: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDetails.IReference"
+                                        },
+                                        description: "Direct type dependencies in source order, with edge evidence."
                                     }
                                 },
                                 required: [
                                     "id",
                                     "name",
                                     "kind",
-                                    "file",
-                                    "score"
+                                    "file"
                                 ],
                                 additionalProperties: false
                             },
-                            "ITtscGraphIndex.IMention": {
+                            "ITtscGraphDetails.IReference": {
                                 type: "object",
                                 properties: {
-                                    candidates: {
+                                    aliases: {
                                         type: "array",
                                         items: {
-                                            $ref: "#/$defs/ITtscGraphIndex.INode"
-                                        }
+                                            type: "string"
+                                        },
+                                        description: "Stable access-path aliases derived from edge evidence. For example, an\nedge to `Owner.member` through `obj.slot.member` may expose\n`Owner.slot.member` so answers can preserve both the resolved symbol and\nthe source access path."
                                     },
-                                    handle: {
-                                        type: "string"
+                                    evidence: {
+                                        $ref: "#/$defs/ITtscGraphEvidence",
+                                        description: "Source span for the expression that produced this relationship. It is\nrepository evidence for the edge, not a file-read instruction."
                                     },
-                                    node: {
-                                        $ref: "#/$defs/ITtscGraphIndex.INode"
+                                    file: {
+                                        type: "string",
+                                        description: "Project-relative declaration file for the neighbor."
+                                    },
+                                    id: {
+                                        type: "string",
+                                        description: "Stable id of the neighboring node."
+                                    },
+                                    kind: {
+                                        type: "string",
+                                        description: "Neighbor declaration kind."
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    name: {
+                                        type: "string",
+                                        description: "Neighbor symbol name, qualified when available."
+                                    },
+                                    relation: {
+                                        type: "string",
+                                        description: "The edge kind connecting the two (`calls`, `type_ref`, ...)."
                                     }
                                 },
                                 required: [
-                                    "handle"
+                                    "id",
+                                    "name",
+                                    "kind",
+                                    "file",
+                                    "relation"
                                 ],
                                 additionalProperties: false
                             },
-                            "ITtscGraphIndex.INeighborhood": {
+                            ITtscGraphEntrypoints: {
                                 type: "object",
                                 properties: {
-                                    dependedOnBy: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "entrypoints"
+                                        ],
+                                        description: "Discriminator for first-pass question indexing."
+                                    },
+                                    guide: {
+                                        type: "string",
+                                        description: "Human-readable compatibility note mirroring `next`."
+                                    },
+                                    hits: {
                                         type: "array",
                                         items: {
-                                            $ref: "#/$defs/ITtscGraphIndex.IReference"
-                                        }
+                                            $ref: "#/$defs/ITtscGraphEntrypoints.IHit"
+                                        },
+                                        description: "Ranked symbols relevant to the query."
                                     },
-                                    dependsOn: {
+                                    mentions: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphEntrypoints.IMention"
+                                        },
+                                        description: "Code handles written directly in the query, resolved when possible."
+                                    },
+                                    neighborhood: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphEntrypoints.INeighborhood"
+                                        },
+                                        description: "Direct dependency context for the resolved mentions and highest hits."
+                                    },
+                                    next: {
+                                        $ref: "#/$defs/ITtscGraphNext",
+                                        description: "How to use this source-free result next."
+                                    },
+                                    query: {
+                                        type: "string",
+                                        description: "The original question/search phrase the entrypoints were built for."
+                                    },
+                                    truncated: {
+                                        type: "boolean",
+                                        description: "True when result caps hid additional seeds or references."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "query",
+                                    "hits",
+                                    "mentions",
+                                    "neighborhood",
+                                    "next",
+                                    "guide"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphEntrypoints.IHit": {
+                                type: "object",
+                                properties: {
+                                    decorators: {
                                         type: "array",
                                         items: {
-                                            $ref: "#/$defs/ITtscGraphIndex.IReference"
-                                        }
+                                            $ref: "#/$defs/ITtscGraphDecorator"
+                                        },
+                                        description: "Decorators written on this declaration, when any."
                                     },
                                     file: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Project-relative path of the declaration file."
                                     },
                                     id: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Stable node id for subsequent graph calls."
                                     },
                                     kind: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Declaration kind (`class`, `method`, `function`, ...)."
                                     },
                                     line: {
                                         type: "number",
                                         description: "1-based declaration line, when known."
                                     },
                                     name: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Qualified symbol name when available, otherwise the simple name."
+                                    },
+                                    score: {
+                                        type: "number",
+                                        description: "Relative relevance; higher is a better match."
                                     },
                                     signature: {
                                         type: "string",
@@ -213,53 +483,77 @@ function createServer(graph, version) {
                                     "name",
                                     "kind",
                                     "file",
-                                    "dependsOn",
-                                    "dependedOnBy"
+                                    "score"
                                 ],
                                 additionalProperties: false
                             },
-                            "ITtscGraphIndex.INext": {
+                            "ITtscGraphEntrypoints.IMention": {
                                 type: "object",
                                 properties: {
-                                    expand: {
+                                    candidates: {
                                         type: "array",
                                         items: {
-                                            type: "string"
+                                            $ref: "#/$defs/ITtscGraphEntrypoints.INode"
                                         },
-                                        description: "Pass these ids to `graph_expand`, with `source: true` only when needed."
+                                        description: "Candidate nodes when the handle is ambiguous."
                                     },
-                                    traceFrom: {
-                                        type: "array",
-                                        items: {
-                                            type: "string"
-                                        },
-                                        description: "Pass these ids to `graph_trace` when following dependency flow."
+                                    handle: {
+                                        type: "string",
+                                        description: "The exact handle text found in the query."
+                                    },
+                                    node: {
+                                        $ref: "#/$defs/ITtscGraphEntrypoints.INode",
+                                        description: "Resolved node when the handle maps unambiguously."
                                     }
                                 },
                                 required: [
-                                    "expand",
-                                    "traceFrom"
+                                    "handle"
                                 ],
                                 additionalProperties: false
                             },
-                            "ITtscGraphIndex.INode": {
+                            "ITtscGraphEntrypoints.INeighborhood": {
                                 type: "object",
                                 properties: {
+                                    decorators: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDecorator"
+                                        },
+                                        description: "Decorators written on this declaration, when any."
+                                    },
+                                    dependedOnBy: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphEntrypoints.IReference"
+                                        },
+                                        description: "Symbols that directly use this node, capped by `neighbors`."
+                                    },
+                                    dependsOn: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphEntrypoints.IReference"
+                                        },
+                                        description: "Symbols this node directly uses, capped by `neighbors`."
+                                    },
                                     file: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Project-relative path of the declaration file."
                                     },
                                     id: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Stable node id for subsequent graph calls."
                                     },
                                     kind: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Declaration kind (`class`, `method`, `function`, ...)."
                                     },
                                     line: {
                                         type: "number",
                                         description: "1-based declaration line, when known."
                                     },
                                     name: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Qualified symbol name when available, otherwise the simple name."
                                     },
                                     signature: {
                                         type: "string",
@@ -270,156 +564,344 @@ function createServer(graph, version) {
                                     "id",
                                     "name",
                                     "kind",
-                                    "file"
+                                    "file",
+                                    "dependsOn",
+                                    "dependedOnBy"
                                 ],
                                 additionalProperties: false
                             },
-                            "ITtscGraphIndex.IReference": {
+                            "ITtscGraphEntrypoints.INode": {
                                 type: "object",
                                 properties: {
+                                    decorators: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDecorator"
+                                        },
+                                        description: "Decorators written on this declaration, when any."
+                                    },
                                     file: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Project-relative path of the declaration file."
                                     },
                                     id: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Stable node id for subsequent graph calls."
                                     },
                                     kind: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Declaration kind (`class`, `method`, `function`, ...)."
                                     },
                                     line: {
                                         type: "number",
                                         description: "1-based declaration line, when known."
                                     },
                                     name: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Qualified symbol name when available, otherwise the simple name."
                                     },
-                                    relation: {
-                                        type: "string"
+                                    signature: {
+                                        type: "string",
+                                        description: "Declaration head, included only for indexed symbols."
                                     }
                                 },
                                 required: [
                                     "id",
                                     "name",
                                     "kind",
-                                    "file",
-                                    "relation"
+                                    "file"
                                 ],
                                 additionalProperties: false
-                            }
-                        }
-                    },
-                    parameters: {
-                        type: "object",
-                        properties: {
-                            limit: {
-                                type: "number",
-                                description: "Maximum ranked hits to return."
                             },
-                            neighbors: {
-                                type: "number",
-                                description: "Maximum direct dependencies and dependents to return per indexed symbol."
+                            "ITtscGraphEntrypoints.IReference": {
+                                type: "object",
+                                properties: {
+                                    evidence: {
+                                        $ref: "#/$defs/ITtscGraphEvidence",
+                                        description: "Source span for the expression that produced this relationship. It lets\nan agent see why the edge exists without opening the file."
+                                    },
+                                    file: {
+                                        type: "string",
+                                        description: "Project-relative declaration file for the neighbor."
+                                    },
+                                    id: {
+                                        type: "string",
+                                        description: "Stable id of the neighboring node."
+                                    },
+                                    kind: {
+                                        type: "string",
+                                        description: "Neighbor declaration kind."
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    name: {
+                                        type: "string",
+                                        description: "Neighbor symbol name, qualified when available."
+                                    },
+                                    relation: {
+                                        type: "string",
+                                        description: "Edge kind connecting the indexed node and this neighbor."
+                                    }
+                                },
+                                required: [
+                                    "id",
+                                    "name",
+                                    "kind",
+                                    "file",
+                                    "relation"
+                                ],
+                                additionalProperties: false
                             },
-                            query: {
-                                type: "string",
-                                description: "A natural code question or search phrase. Mix prose with code handles,\nfor example `how Repository.find loads relations` or\n`SelectQueryBuilder.setFindOptions join aliases`."
-                            }
-                        },
-                        required: [
-                            "query"
-                        ],
-                        additionalProperties: false,
-                        $defs: {}
-                    },
-                    validate: (() => {
-                        const _io0 = input => "string" === typeof input.query && (undefined === input.limit || "number" === typeof input.limit) && (undefined === input.neighbors || "number" === typeof input.neighbors);
-                        const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.query || _report(_exceptionable, {
-                                path: _path + ".query",
-                                expected: "string",
-                                value: input.query
-                            }), undefined === input.limit || "number" === typeof input.limit || _report(_exceptionable, {
-                                path: _path + ".limit",
-                                expected: "(number | undefined)",
-                                value: input.limit
-                            }), undefined === input.neighbors || "number" === typeof input.neighbors || _report(_exceptionable, {
-                                path: _path + ".neighbors",
-                                expected: "(number | undefined)",
-                                value: input.neighbors
-                            })].every(flag => flag);
-                        const __is = input => "object" === typeof input && null !== input && _io0(input);
-                        let errors;
-                        let _report;
-                        return input => {
-                            if (false === __is(input)) {
-                                errors = [];
-                                _report = _b._validateReport(errors);
-                                ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
-                                    path: _path + "",
-                                    expected: "ITtscGraphIndex.IProps",
-                                    value: input
-                                })) && _vo0(input, _path + "", true) || _report(true, {
-                                    path: _path + "",
-                                    expected: "ITtscGraphIndex.IProps",
-                                    value: input
-                                }))(input, "$input", true);
-                                const success = 0 === errors.length;
-                                return success ? {
-                                    success,
-                                    data: input
-                                } : {
-                                    success,
-                                    errors,
-                                    data: input
-                                };
-                            }
-                            return {
-                                success: true,
-                                data: input
-                            };
-                        };
-                    })()
-                },
-                {
-                    description: "The project's architecture \u2014 folder layers, dependency hotspots, and the\npublic API. Call first to orient on an unfamiliar codebase.",
-                    name: "graph_overview",
-                    output: {
-                        type: "object",
-                        properties: {
-                            counts: {
-                                $ref: "#/$defs/ITtscGraphOverview.ICounts",
-                                description: "Size of the graph."
+                            ITtscGraphEscape: {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "escape"
+                                        ],
+                                        description: "Discriminator for the no-op escape route."
+                                    },
+                                    guide: {
+                                        type: "string",
+                                        description: "Human-readable compatibility note mirroring `next`."
+                                    },
+                                    next: {
+                                        $ref: "#/$defs/ITtscGraphNext",
+                                        description: "How to proceed after skipping graph work."
+                                    },
+                                    nextStep: {
+                                        type: "string",
+                                        description: "Optional note about the next non-graph step."
+                                    },
+                                    reason: {
+                                        type: "string",
+                                        description: "Why no graph operation should run."
+                                    },
+                                    skipped: {
+                                        type: "boolean",
+                                        "enum": [
+                                            true
+                                        ],
+                                        description: "Always true so callers can distinguish an intentional no-op."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "skipped",
+                                    "reason",
+                                    "next",
+                                    "guide"
+                                ],
+                                additionalProperties: false
+                            },
+                            ITtscGraphEvidence: {
+                                type: "object",
+                                properties: {
+                                    endCol: {
+                                        type: "number",
+                                        description: "1-based column where the span ends, when known."
+                                    },
+                                    endLine: {
+                                        type: "number",
+                                        description: "1-based line where the span ends, when it differs from `startLine`."
+                                    },
+                                    file: {
+                                        type: "string",
+                                        description: "Project-relative path of the file the span lives in."
+                                    },
+                                    startCol: {
+                                        type: "number",
+                                        description: "1-based column where the span starts, when known."
+                                    },
+                                    startLine: {
+                                        type: "number",
+                                        description: "1-based line where the span starts."
+                                    }
+                                },
+                                required: [
+                                    "file",
+                                    "startLine"
+                                ],
+                                additionalProperties: false
                             },
-                            hotspots: {
-                                type: "array",
-                                items: {
-                                    $ref: "#/$defs/ITtscGraphOverview.IHotspot"
+                            ITtscGraphLookup: {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "lookup"
+                                        ],
+                                        description: "Discriminator for targeted symbol lookup."
+                                    },
+                                    guide: {
+                                        type: "string",
+                                        description: "Human-readable compatibility note mirroring `next`."
+                                    },
+                                    hits: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphLookup.IHit"
+                                        },
+                                        description: "Ranked symbol matches for the query."
+                                    },
+                                    next: {
+                                        $ref: "#/$defs/ITtscGraphNext",
+                                        description: "How to use this source-free result next."
+                                    }
                                 },
-                                description: "Highest-dependency symbols, busiest first."
+                                required: [
+                                    "type",
+                                    "hits",
+                                    "next",
+                                    "guide"
+                                ],
+                                additionalProperties: false
                             },
-                            layers: {
-                                type: "array",
-                                items: {
-                                    $ref: "#/$defs/ITtscGraphOverview.ILayer"
+                            "ITtscGraphLookup.IHit": {
+                                type: "object",
+                                properties: {
+                                    decorators: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDecorator"
+                                        },
+                                        description: "Decorators written on this declaration, when any."
+                                    },
+                                    file: {
+                                        type: "string",
+                                        description: "Project-relative path of the declaration file."
+                                    },
+                                    id: {
+                                        type: "string",
+                                        description: "Stable node id for subsequent graph calls."
+                                    },
+                                    kind: {
+                                        type: "string",
+                                        description: "Declaration kind (`class`, `method`, `function`, ...)."
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    name: {
+                                        type: "string",
+                                        description: "Qualified symbol name when available, otherwise the simple name."
+                                    },
+                                    score: {
+                                        type: "number",
+                                        description: "Relative relevance; higher is a better match."
+                                    },
+                                    signature: {
+                                        type: "string",
+                                        description: "The hit's declaration signature, so you can often answer without\nrequesting details."
+                                    }
                                 },
-                                description: "Folder layering, largest first."
+                                required: [
+                                    "id",
+                                    "name",
+                                    "kind",
+                                    "file",
+                                    "score"
+                                ],
+                                additionalProperties: false
                             },
-                            project: {
-                                type: "string",
-                                description: "Absolute project root."
+                            ITtscGraphNext: {
+                                type: "object",
+                                properties: {
+                                    action: {
+                                        type: "string",
+                                        "enum": [
+                                            "answer",
+                                            "clarify",
+                                            "inspect",
+                                            "outside"
+                                        ],
+                                        description: "Answer, continue graph inspection, leave graph, or clarify.\n\n`answer` means the returned graph result already carries the evidence\ncontract for the current question, even when the slice is capped. Do not\ncall graph again or read files to re-check or complete it."
+                                    },
+                                    reason: {
+                                        type: "string",
+                                        description: "Why the returned graph evidence supports that action."
+                                    },
+                                    request: {
+                                        type: "string",
+                                        "enum": [
+                                            "details",
+                                            "entrypoints",
+                                            "lookup",
+                                            "overview",
+                                            "tour",
+                                            "trace"
+                                        ],
+                                        description: "Smallest graph request type to use when `action` is `inspect`."
+                                    }
+                                },
+                                required: [
+                                    "action",
+                                    "reason"
+                                ],
+                                additionalProperties: false
                             },
-                            publicApi: {
-                                type: "array",
-                                items: {
-                                    $ref: "#/$defs/ITtscGraphOverview.IPublicApi"
+                            ITtscGraphOverview: {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "overview"
+                                        ],
+                                        description: "Discriminator for source-free project overview."
+                                    },
+                                    counts: {
+                                        $ref: "#/$defs/ITtscGraphOverview.ICounts",
+                                        description: "Size of the graph."
+                                    },
+                                    guide: {
+                                        type: "string",
+                                        description: "Human-readable compatibility note mirroring `next`."
+                                    },
+                                    hotspots: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphOverview.IHotspot"
+                                        },
+                                        description: "Highest-dependency symbols, busiest first."
+                                    },
+                                    layers: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphOverview.ILayer"
+                                        },
+                                        description: "Folder layering, largest first."
+                                    },
+                                    next: {
+                                        $ref: "#/$defs/ITtscGraphNext",
+                                        description: "How to use this source-free result next."
+                                    },
+                                    project: {
+                                        type: "string",
+                                        description: "Absolute project root."
+                                    },
+                                    publicApi: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphOverview.INode"
+                                        },
+                                        description: "Exported API symbols, most-depended-on first."
+                                    }
                                 },
-                                description: "Exported API symbols, most-depended-on first."
-                            }
-                        },
-                        required: [
-                            "project",
-                            "counts"
-                        ],
-                        additionalProperties: false,
-                        $defs: {
+                                required: [
+                                    "type",
+                                    "project",
+                                    "counts",
+                                    "next",
+                                    "guide"
+                                ],
+                                additionalProperties: false
+                            },
                             "ITtscGraphOverview.ICounts": {
                                 type: "object",
                                 properties: {
@@ -428,13 +910,16 @@ function createServer(graph, version) {
                                         description: "Node count per kind."
                                     },
                                     edges: {
-                                        type: "number"
+                                        type: "number",
+                                        description: "Total edge count, including structural edges."
                                     },
                                     files: {
-                                        type: "number"
+                                        type: "number",
+                                        description: "Number of source file container nodes."
                                     },
                                     nodes: {
-                                        type: "number"
+                                        type: "number",
+                                        description: "Total node count, including declarations and file containers."
                                     }
                                 },
                                 required: [
@@ -457,16 +942,24 @@ function createServer(graph, version) {
                                         description: "Non-structural edges leaving this symbol."
                                     },
                                     file: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Project-relative path of the file that declares it."
                                     },
                                     id: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Stable handle for `details` or `trace`."
                                     },
                                     kind: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Its declaration kind (`class`, `interface`, `function`, ...)."
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
                                     },
                                     name: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "The symbol's qualified name when available."
                                     }
                                 },
                                 required: [
@@ -502,529 +995,373 @@ function createServer(graph, version) {
                                 ],
                                 additionalProperties: false
                             },
-                            "ITtscGraphOverview.IPublicApi": {
+                            "ITtscGraphOverview.INode": {
                                 type: "object",
                                 properties: {
                                     file: {
                                         type: "string",
                                         description: "Project-relative path of the file that declares it."
                                     },
+                                    id: {
+                                        type: "string",
+                                        description: "Stable handle for `details` or `trace`."
+                                    },
                                     kind: {
                                         type: "string",
-                                        description: "Its declaration kind (`class`, `interface`, `function`, \u2026)."
+                                        description: "Its declaration kind (`class`, `interface`, `function`, ...)."
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
                                     },
                                     name: {
                                         type: "string",
-                                        description: "The exported symbol's name."
+                                        description: "The symbol's qualified name when available."
                                     }
                                 },
                                 required: [
+                                    "id",
                                     "name",
                                     "kind",
                                     "file"
                                 ],
                                 additionalProperties: false
                             },
-                            Recordstringnumber: {
-                                type: "object",
-                                properties: {},
-                                required: [],
-                                additionalProperties: {
-                                    type: "number"
-                                }
-                            }
-                        }
-                    },
-                    parameters: {
-                        type: "object",
-                        properties: {
-                            aspect: {
-                                type: "string",
-                                "enum": [
-                                    "all",
-                                    "hotspots",
-                                    "layers",
-                                    "publicApi"
-                                ],
-                                description: "The facet to project, or `all` for every facet. `layers` is the folder\nlayering, `hotspots` the highest-dependency symbols, `publicApi` the\nexported API symbols ranked by how depended-on they are."
-                            }
-                        },
-                        required: [],
-                        additionalProperties: false,
-                        $defs: {}
-                    },
-                    validate: (() => {
-                        const _io0 = input => undefined === input.aspect || "all" === input.aspect || "hotspots" === input.aspect || "layers" === input.aspect || "publicApi" === input.aspect;
-                        const _vo0 = (input, _path, _exceptionable = true) => [undefined === input.aspect || "all" === input.aspect || "hotspots" === input.aspect || "layers" === input.aspect || "publicApi" === input.aspect || _report(_exceptionable, {
-                                path: _path + ".aspect",
-                                expected: "(\"all\" | \"hotspots\" | \"layers\" | \"publicApi\" | undefined)",
-                                value: input.aspect
-                            })].every(flag => flag);
-                        const __is = input => "object" === typeof input && null !== input && false === Array.isArray(input) && _io0(input);
-                        let errors;
-                        let _report;
-                        return input => {
-                            if (false === __is(input)) {
-                                errors = [];
-                                _report = _b._validateReport(errors);
-                                ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input && false === Array.isArray(input) || _report(true, {
-                                    path: _path + "",
-                                    expected: "ITtscGraphOverview.IProps",
-                                    value: input
-                                })) && _vo0(input, _path + "", true) || _report(true, {
-                                    path: _path + "",
-                                    expected: "ITtscGraphOverview.IProps",
-                                    value: input
-                                }))(input, "$input", true);
-                                const success = 0 === errors.length;
-                                return success ? {
-                                    success,
-                                    data: input
-                                } : {
-                                    success,
-                                    errors,
-                                    data: input
-                                };
-                            }
-                            return {
-                                success: true,
-                                data: input
-                            };
-                        };
-                    })()
-                },
-                {
-                    description: "The declared shape of the given symbols: each one's signature, and for a\nclass/interface/namespace its members. Handles may be ids or dotted symbol\nnames. Set `source: true` to also read a specific body, `neighbors: true`\nto list what it uses and what uses it.",
-                    name: "graph_expand",
-                    output: {
-                        type: "object",
-                        properties: {
-                            nodes: {
-                                type: "array",
-                                items: {
-                                    $ref: "#/$defs/ITtscGraphExpand.INode"
-                                }
-                            },
-                            unknown: {
-                                type: "array",
-                                items: {
-                                    type: "string"
-                                },
-                                description: "Handles that resolved to no node, or that were ambiguous."
-                            }
-                        },
-                        required: [
-                            "nodes",
-                            "unknown"
-                        ],
-                        additionalProperties: false,
-                        $defs: {
-                            "ITtscGraphExpand.IMember": {
+                            ITtscGraphTour: {
                                 type: "object",
                                 properties: {
-                                    kind: {
-                                        type: "string"
-                                    },
-                                    line: {
-                                        type: "number",
-                                        description: "1-based declaration line, when known."
-                                    },
-                                    name: {
-                                        type: "string"
-                                    },
-                                    signature: {
+                                    type: {
                                         type: "string",
-                                        description: "The member's declaration signature."
-                                    }
-                                },
-                                required: [
-                                    "name",
-                                    "kind"
-                                ],
-                                additionalProperties: false
-                            },
-                            "ITtscGraphExpand.INode": {
-                                type: "object",
-                                properties: {
-                                    dependedOnBy: {
+                                        "enum": [
+                                            "tour"
+                                        ],
+                                        description: "Discriminator for code-tour indexing."
+                                    },
+                                    answerAnchors: {
                                         type: "array",
                                         items: {
-                                            $ref: "#/$defs/ITtscGraphExpand.IReference"
+                                            $ref: "#/$defs/ITtscGraphTour.IAnchor"
                                         },
-                                        description: "Symbols that use this node (incoming dependency edges)."
+                                        description: "Ordered file/line anchors to cite in the final answer, not file reads."
                                     },
-                                    dependsOn: {
+                                    entrypoints: {
                                         type: "array",
                                         items: {
-                                            $ref: "#/$defs/ITtscGraphExpand.IReference"
+                                            $ref: "#/$defs/ITtscGraphTour.INode"
                                         },
-                                        description: "Symbols this node uses (outgoing dependency edges)."
+                                        description: "Central entrypoints selected for the tour."
                                     },
-                                    file: {
-                                        type: "string"
-                                    },
-                                    id: {
-                                        type: "string"
+                                    guide: {
+                                        type: "string",
+                                        description: "Human-readable compatibility note mirroring `next`."
                                     },
-                                    kind: {
-                                        type: "string"
+                                    nearby: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphTour.IAnchor"
+                                        },
+                                        description: "Nearby dependency anchors around the selected entrypoints."
                                     },
-                                    line: {
-                                        type: "number",
-                                        description: "1-based declaration line, when known."
+                                    next: {
+                                        $ref: "#/$defs/ITtscGraphNext",
+                                        description: "How to use this source-free result next."
                                     },
-                                    members: {
+                                    primaryFlow: {
                                         type: "array",
                                         items: {
-                                            $ref: "#/$defs/ITtscGraphExpand.IMember"
+                                            $ref: "#/$defs/ITtscGraphTour.IFlow"
                                         },
-                                        description: "For a class, interface, namespace, module, enum, or file: the symbols it\ncontains, each with its own signature \u2014 the member outline a consumer\nreaches for, without the bodies."
-                                    },
-                                    name: {
-                                        type: "string"
+                                        description: "Selected primary runtime flows; sufficient for an index-level tour."
                                     },
-                                    signature: {
+                                    query: {
                                         type: "string",
-                                        description: "The declaration signature \u2014 its first line(s) up to the body."
+                                        description: "Natural code question this tour was built for."
                                     },
-                                    source: {
-                                        type: "string",
-                                        description: "The full declaration source \u2014 only when `source` was requested."
+                                    tests: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphTour.IAnchor"
+                                        },
+                                        description: "Test or usage anchors reached through graph impact edges."
                                     },
                                     truncated: {
                                         type: "boolean",
-                                        description: "True when `source` was cut at the line cap."
+                                        description: "True when any internal slice hit its cap."
                                     }
                                 },
                                 required: [
-                                    "id",
-                                    "name",
-                                    "kind",
-                                    "file"
+                                    "type",
+                                    "query",
+                                    "entrypoints",
+                                    "primaryFlow",
+                                    "nearby",
+                                    "tests",
+                                    "answerAnchors",
+                                    "next",
+                                    "guide"
                                 ],
                                 additionalProperties: false
                             },
-                            "ITtscGraphExpand.IReference": {
+                            "ITtscGraphTour.IAnchor": {
                                 type: "object",
                                 properties: {
+                                    endLine: {
+                                        type: "number",
+                                        description: "1-based end line, when known."
+                                    },
+                                    file: {
+                                        type: "string",
+                                        description: "Project-relative file."
+                                    },
                                     id: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Stable node id when the anchor belongs to a node."
                                     },
                                     kind: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Declaration kind, when this anchor belongs to a node."
                                     },
                                     name: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Symbol, edge, or test name to show in the answer."
                                     },
-                                    relation: {
+                                    reason: {
                                         type: "string",
-                                        description: "The edge kind connecting the two (`calls`, `type_ref`, \u2026)."
+                                        description: "Why this anchor matters in the tour."
+                                    },
+                                    startLine: {
+                                        type: "number",
+                                        description: "1-based start line."
                                     }
                                 },
                                 required: [
-                                    "id",
+                                    "reason",
                                     "name",
-                                    "kind",
-                                    "relation"
+                                    "file",
+                                    "startLine"
                                 ],
                                 additionalProperties: false
-                            }
-                        }
-                    },
-                    parameters: {
-                        type: "object",
-                        properties: {
-                            handles: {
-                                type: "array",
-                                items: {
-                                    type: "string"
-                                },
-                                description: "Node ids from another tool, or dotted symbol handles such as\n`OrderService.create`. Pass every handle you need in one call."
-                            },
-                            neighbors: {
-                                type: "boolean",
-                                description: "Also list each node's direct dependencies and dependents (the symbols it\nuses and the symbols that use it)."
                             },
-                            source: {
-                                type: "boolean",
-                                description: "Return the full declaration source body too. Off by default: expand\nreturns the declared shape \u2014 a symbol's signature, and a class/interface/\nnamespace's member outline \u2014 which is what you usually need and a\nfraction of the tokens. Turn this on only for the few leaf functions or\nmethods whose actual control-flow logic you must read."
-                            }
-                        },
-                        required: [
-                            "handles"
-                        ],
-                        additionalProperties: false,
-                        $defs: {}
-                    },
-                    validate: (() => {
-                        const _io0 = input => Array.isArray(input.handles) && input.handles.every(elem => "string" === typeof elem) && (undefined === input.neighbors || "boolean" === typeof input.neighbors) && (undefined === input.source || "boolean" === typeof input.source);
-                        const _vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.handles) || _report(_exceptionable, {
-                                path: _path + ".handles",
-                                expected: "Array<string>",
-                                value: input.handles
-                            })) && input.handles.map((elem, _index2) => "string" === typeof elem || _report(_exceptionable, {
-                                path: _path + ".handles[" + _index2 + "]",
-                                expected: "string",
-                                value: elem
-                            })).every(flag => flag) || _report(_exceptionable, {
-                                path: _path + ".handles",
-                                expected: "Array<string>",
-                                value: input.handles
-                            }), undefined === input.neighbors || "boolean" === typeof input.neighbors || _report(_exceptionable, {
-                                path: _path + ".neighbors",
-                                expected: "(boolean | undefined)",
-                                value: input.neighbors
-                            }), undefined === input.source || "boolean" === typeof input.source || _report(_exceptionable, {
-                                path: _path + ".source",
-                                expected: "(boolean | undefined)",
-                                value: input.source
-                            })].every(flag => flag);
-                        const __is = input => "object" === typeof input && null !== input && _io0(input);
-                        let errors;
-                        let _report;
-                        return input => {
-                            if (false === __is(input)) {
-                                errors = [];
-                                _report = _b._validateReport(errors);
-                                ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
-                                    path: _path + "",
-                                    expected: "ITtscGraphExpand.IProps",
-                                    value: input
-                                })) && _vo0(input, _path + "", true) || _report(true, {
-                                    path: _path + "",
-                                    expected: "ITtscGraphExpand.IProps",
-                                    value: input
-                                }))(input, "$input", true);
-                                const success = 0 === errors.length;
-                                return success ? {
-                                    success,
-                                    data: input
-                                } : {
-                                    success,
-                                    errors,
-                                    data: input
-                                };
-                            }
-                            return {
-                                success: true,
-                                data: input
-                            };
-                        };
-                    })()
-                },
-                {
-                    description: "Find any symbol \u2014 class, function, method, or field \u2014 by name or\ndescription. Each hit comes with its signature, so the query alone often\nanswers the question, and `next.expand` gives handles for source\nfollow-up.",
-                    name: "graph_query",
-                    output: {
-                        type: "object",
-                        properties: {
-                            hits: {
-                                type: "array",
-                                items: {
-                                    $ref: "#/$defs/ITtscGraphQuery.IHit"
-                                }
+                            "ITtscGraphTour.IFlow": {
+                                type: "object",
+                                properties: {
+                                    anchors: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphTour.IAnchor"
+                                        },
+                                        description: "Edge and node anchors that explain the flow."
+                                    },
+                                    reached: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphTour.INode"
+                                        },
+                                        description: "Nodes reached by this flow."
+                                    },
+                                    start: {
+                                        $ref: "#/$defs/ITtscGraphTour.INode",
+                                        description: "Flow start node."
+                                    },
+                                    steps: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Compact edge summaries in graph order."
+                                    },
+                                    truncated: {
+                                        type: "boolean",
+                                        description: "True when the flow hit graph caps."
+                                    }
+                                },
+                                required: [
+                                    "start",
+                                    "steps",
+                                    "reached",
+                                    "anchors"
+                                ],
+                                additionalProperties: false
                             },
-                            next: {
-                                $ref: "#/$defs/ITtscGraphQuery.INext",
-                                description: "Follow-up handles for source or member details."
-                            }
-                        },
-                        required: [
-                            "hits",
-                            "next"
-                        ],
-                        additionalProperties: false,
-                        $defs: {
-                            "ITtscGraphQuery.IHit": {
+                            "ITtscGraphTour.INode": {
                                 type: "object",
                                 properties: {
+                                    decorators: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDecorator"
+                                        },
+                                        description: "Decorators written on the declaration, when any."
+                                    },
                                     file: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Project-relative declaration file."
                                     },
                                     id: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Stable node id for later graph calls."
                                     },
                                     kind: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Declaration kind (`class`, `method`, `function`, ...)."
                                     },
                                     line: {
                                         type: "number",
                                         description: "1-based declaration line, when known."
                                     },
                                     name: {
-                                        type: "string"
-                                    },
-                                    score: {
-                                        type: "number",
-                                        description: "Relative relevance; higher is a better match."
+                                        type: "string",
+                                        description: "Qualified symbol name when available, otherwise the simple name."
                                     },
                                     signature: {
                                         type: "string",
-                                        description: "The hit's declaration signature, so you can often answer without\nexpanding."
+                                        description: "Declaration head, when available."
+                                    },
+                                    sourceSpan: {
+                                        $ref: "#/$defs/ITtscGraphTour.ISpan",
+                                        description: "Declaration or implementation range, when known."
                                     }
                                 },
                                 required: [
                                     "id",
                                     "name",
                                     "kind",
-                                    "file",
-                                    "score"
+                                    "file"
                                 ],
                                 additionalProperties: false
                             },
-                            "ITtscGraphQuery.INext": {
+                            "ITtscGraphTour.ISpan": {
                                 type: "object",
                                 properties: {
-                                    expand: {
-                                        type: "array",
-                                        items: {
-                                            type: "string"
-                                        },
-                                        description: "Pass these ids to `graph_expand`, with `source: true` only when needed."
+                                    endLine: {
+                                        type: "number",
+                                        description: "1-based end line, when known."
+                                    },
+                                    file: {
+                                        type: "string",
+                                        description: "Project-relative file."
+                                    },
+                                    startLine: {
+                                        type: "number",
+                                        description: "1-based start line."
                                     }
                                 },
                                 required: [
-                                    "expand"
+                                    "file",
+                                    "startLine"
                                 ],
                                 additionalProperties: false
-                            }
-                        }
-                    },
-                    parameters: {
-                        type: "object",
-                        properties: {
-                            limit: {
-                                type: "number",
-                                description: "Maximum hits to return."
                             },
-                            query: {
-                                type: "string",
-                                description: "What to find, in natural language and code vocabulary mixed freely \u2014 a\nsymbol name, a dotted member (`OrderService.create`), or a phrase\n(`shopping order create`, `repository find relations`). Exact names are\nnot required; subword and CamelCase matches rank too."
-                            }
-                        },
-                        required: [
-                            "query"
-                        ],
-                        additionalProperties: false,
-                        $defs: {}
-                    },
-                    validate: (() => {
-                        const _io0 = input => "string" === typeof input.query && (undefined === input.limit || "number" === typeof input.limit);
-                        const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.query || _report(_exceptionable, {
-                                path: _path + ".query",
-                                expected: "string",
-                                value: input.query
-                            }), undefined === input.limit || "number" === typeof input.limit || _report(_exceptionable, {
-                                path: _path + ".limit",
-                                expected: "(number | undefined)",
-                                value: input.limit
-                            })].every(flag => flag);
-                        const __is = input => "object" === typeof input && null !== input && _io0(input);
-                        let errors;
-                        let _report;
-                        return input => {
-                            if (false === __is(input)) {
-                                errors = [];
-                                _report = _b._validateReport(errors);
-                                ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
-                                    path: _path + "",
-                                    expected: "ITtscGraphQuery.IProps",
-                                    value: input
-                                })) && _vo0(input, _path + "", true) || _report(true, {
-                                    path: _path + "",
-                                    expected: "ITtscGraphQuery.IProps",
-                                    value: input
-                                }))(input, "$input", true);
-                                const success = 0 === errors.length;
-                                return success ? {
-                                    success,
-                                    data: input
-                                } : {
-                                    success,
-                                    errors,
-                                    data: input
-                                };
-                            }
-                            return {
-                                success: true,
-                                data: input
-                            };
-                        };
-                    })()
-                },
-                {
-                    description: "Follow dependency flow from a symbol: `forward` to what it uses, `reverse`\nto what uses it, or `impact` to the public API and tests a change reaches.\nGive `from`/`to` as ids or dotted names to get the path between two symbols\nin one call \u2014 how A reaches B.",
-                    name: "graph_trace",
-                    output: {
-                        type: "object",
-                        properties: {
-                            candidates: {
-                                type: "array",
-                                items: {
-                                    $ref: "#/$defs/ITtscGraphTrace.INode"
-                                },
-                                description: "When `from` was an ambiguous name, the matches to disambiguate with."
-                            },
-                            direction: {
-                                type: "string"
-                            },
-                            hops: {
-                                type: "array",
-                                items: {
-                                    $ref: "#/$defs/ITtscGraphTrace.IHop"
-                                },
-                                description: "Edges traversed, in breadth-first order."
-                            },
-                            path: {
-                                type: "array",
-                                items: {
-                                    $ref: "#/$defs/ITtscGraphTrace.INode"
-                                },
-                                description: "When `to` was given: the ordered dependency path from `from` to `to`\n(`from` first, `to` last), or empty when `to` is not reachable from\n`from`."
-                            },
-                            reached: {
-                                type: "array",
-                                items: {
-                                    $ref: "#/$defs/ITtscGraphTrace.INode"
+                            ITtscGraphTrace: {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "trace"
+                                        ],
+                                        description: "Discriminator for dependency tracing."
+                                    },
+                                    candidates: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphTrace.INode"
+                                        },
+                                        description: "When `from` was an ambiguous name, the matches to disambiguate with."
+                                    },
+                                    direction: {
+                                        type: "string",
+                                        description: "Trace direction actually used by this result."
+                                    },
+                                    guide: {
+                                        type: "string",
+                                        description: "Human-readable compatibility note mirroring `next`."
+                                    },
+                                    hops: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphTrace.IHop"
+                                        },
+                                        description: "Edges traversed, in breadth-first order."
+                                    },
+                                    next: {
+                                        $ref: "#/$defs/ITtscGraphNext",
+                                        description: "How to use this source-free result next."
+                                    },
+                                    path: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphTrace.INode"
+                                        },
+                                        description: "When `to` was given: the ordered dependency path from `from` to `to`\n(`from` first, `to` last), or empty when `to` is not reachable from\n`from`."
+                                    },
+                                    reached: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphTrace.INode"
+                                        },
+                                        description: "Unique nodes reached (excluding the start), each with its depth and roles."
+                                    },
+                                    start: {
+                                        $ref: "#/$defs/ITtscGraphTrace.INode",
+                                        description: "The resolved start node, or undefined when `from` matched nothing."
+                                    },
+                                    steps: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Compact hop summaries preserving node names and edge evidence, capped."
+                                    },
+                                    target: {
+                                        $ref: "#/$defs/ITtscGraphTrace.INode",
+                                        description: "The resolved `to` target, when a path was requested."
+                                    },
+                                    truncated: {
+                                        type: "boolean",
+                                        description: "True when the trace hit maxNodes or maxDepth and more flow exists."
+                                    }
                                 },
-                                description: "Unique nodes reached (excluding the start), each with its depth and roles."
-                            },
-                            start: {
-                                $ref: "#/$defs/ITtscGraphTrace.INode",
-                                description: "The resolved start node, or undefined when `from` matched nothing."
-                            },
-                            target: {
-                                $ref: "#/$defs/ITtscGraphTrace.INode",
-                                description: "The resolved `to` target, when a path was requested."
+                                required: [
+                                    "type",
+                                    "direction",
+                                    "hops",
+                                    "reached",
+                                    "truncated",
+                                    "next",
+                                    "guide"
+                                ],
+                                additionalProperties: false
                             },
-                            truncated: {
-                                type: "boolean",
-                                description: "True when the trace hit maxNodes or maxDepth and more flow exists."
-                            }
-                        },
-                        required: [
-                            "direction",
-                            "hops",
-                            "reached",
-                            "truncated"
-                        ],
-                        additionalProperties: false,
-                        $defs: {
                             "ITtscGraphTrace.IHop": {
                                 type: "object",
                                 properties: {
+                                    aliases: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Stable access-path aliases derived from edge evidence. These preserve a\nresolved member's owner and the concrete property path used at the call\nsite."
+                                    },
                                     depth: {
                                         type: "number",
                                         description: "Hops from the start (1 = direct)."
                                     },
+                                    evidence: {
+                                        $ref: "#/$defs/ITtscGraphEvidence",
+                                        description: "Source span for the expression that produced this hop. It is repository\nevidence for the hop and can be cited without opening the file."
+                                    },
                                     from: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Source node id for this traversed edge."
                                     },
                                     kind: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Edge kind (`calls`, `type_ref`, `accesses`, ...)."
                                     },
                                     to: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Target node id for this traversed edge."
                                     }
                                 },
                                 required: [
@@ -1043,16 +1380,24 @@ function createServer(graph, version) {
                                         description: "Hops from the start, on a reached node."
                                     },
                                     file: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Project-relative path of the declaration file."
                                     },
                                     id: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Stable node id for subsequent graph calls."
                                     },
                                     kind: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Declaration kind (`class`, `method`, `function`, ...)."
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
                                     },
                                     name: {
-                                        type: "string"
+                                        type: "string",
+                                        description: "Qualified symbol name when available, otherwise the simple name."
                                     },
                                     roles: {
                                         type: "array",
@@ -1063,7 +1408,11 @@ function createServer(graph, version) {
                                     },
                                     signature: {
                                         type: "string",
-                                        description: "The node's signature \u2014 carried on path nodes so the path explains itself."
+                                        description: "The node's signature, carried on path nodes so the path explains itself."
+                                    },
+                                    sourceSpan: {
+                                        $ref: "#/$defs/PickITtscGraphEvidenceendLinefilestartLine",
+                                        description: "Declaration or implementation citation range, when known."
                                     }
                                 },
                                 required: [
@@ -1073,47 +1422,490 @@ function createServer(graph, version) {
                                     "file"
                                 ],
                                 additionalProperties: false
+                            },
+                            PickITtscGraphEvidenceendLinefilestartLine: {
+                                type: "object",
+                                properties: {
+                                    endLine: {
+                                        type: "number",
+                                        description: "1-based line where the span ends, when it differs from `startLine`."
+                                    },
+                                    file: {
+                                        type: "string",
+                                        description: "Project-relative path of the file the span lives in."
+                                    },
+                                    startLine: {
+                                        type: "number",
+                                        description: "1-based line where the span starts."
+                                    }
+                                },
+                                required: [
+                                    "file",
+                                    "startLine"
+                                ],
+                                additionalProperties: false
+                            },
+                            Recordstringnumber: {
+                                type: "object",
+                                properties: {},
+                                required: [],
+                                additionalProperties: {
+                                    type: "number"
+                                }
                             }
                         }
                     },
                     parameters: {
                         type: "object",
                         properties: {
-                            direction: {
+                            draft: {
                                 type: "string",
-                                "enum": [
-                                    "forward",
-                                    "impact",
-                                    "reverse"
-                                ],
-                                description: "`forward` follows what the start uses (callees, instantiations, renders);\n`reverse` follows what uses the start (callers); `impact` is a reverse\ntrace that flags the public API and tests a change would reach."
+                                description: "Initial request plan before final arguments are filled.\n\nName the intended request type and why it seems smallest. Broad flow,\narchitecture, repository-orientation, and read-next questions should\nnormally draft `tour`; narrow named symbols can draft `lookup`, `trace`,\nor `details`."
                             },
-                            from: {
+                            question: {
                                 type: "string",
-                                description: "Where to start: a node id from another tool, a simple symbol name, or a\ndotted member name such as `OrderService.create`. An ambiguous name\nreturns its candidates instead of a trace."
+                                description: "User's TypeScript code question.\n\nRestate the code question being considered. If the next evidence is a\nscript, config, doc, generated output, exact text, non-TypeScript file,\nor source body text, choose `escape`."
                             },
-                            maxDepth: {
-                                type: "number",
-                                description: "How many hops deep to follow."
-                            },
-                            maxNodes: {
-                                type: "number",
-                                description: "Cap on reached nodes; the trace stops and marks itself truncated past it."
+                            request: {
+                                anyOf: [
+                                    {
+                                        $ref: "#/$defs/ITtscGraphDetails.IRequest"
+                                    },
+                                    {
+                                        $ref: "#/$defs/ITtscGraphEntrypoints.IRequest"
+                                    },
+                                    {
+                                        $ref: "#/$defs/ITtscGraphLookup.IRequest"
+                                    },
+                                    {
+                                        $ref: "#/$defs/ITtscGraphOverview.IRequest"
+                                    },
+                                    {
+                                        $ref: "#/$defs/ITtscGraphTour.IRequest"
+                                    },
+                                    {
+                                        $ref: "#/$defs/ITtscGraphTrace.IRequest"
+                                    },
+                                    {
+                                        $ref: "#/$defs/ITtscGraphEscape.IRequest"
+                                    }
+                                ],
+                                description: "Final graph operation chosen after review, or a no-op escape.",
+                                "x-discriminator": {
+                                    mapping: {
+                                        details: "#/$defs/ITtscGraphDetails.IRequest",
+                                        entrypoints: "#/$defs/ITtscGraphEntrypoints.IRequest",
+                                        escape: "#/$defs/ITtscGraphEscape.IRequest",
+                                        lookup: "#/$defs/ITtscGraphLookup.IRequest",
+                                        overview: "#/$defs/ITtscGraphOverview.IRequest",
+                                        tour: "#/$defs/ITtscGraphTour.IRequest",
+                                        trace: "#/$defs/ITtscGraphTrace.IRequest"
+                                    },
+                                    propertyName: "type"
+                                }
                             },
-                            to: {
+                            review: {
                                 type: "string",
-                                description: "A target symbol: node id, simple symbol name, or dotted member name. When\ngiven, the tool returns the dependency path from `from` to this target \u2014\nthe one-call answer for \"how does A reach B\" \u2014 instead of an open-ended\ntrace."
+                                description: "Final self-review before calling.\n\nCorrect a stale, broad, duplicate, or wrong draft here. If broad flow was\nsplit into search/detail steps, switch to `tour`. If graph facts already\nanswer, or prior `next.action` was `answer`, make `request.type` be\n`escape`; do not call graph or read files to re-confirm returned facts."
                             }
                         },
                         required: [
-                            "from"
+                            "question",
+                            "draft",
+                            "review",
+                            "request"
                         ],
                         additionalProperties: false,
-                        $defs: {}
+                        $defs: {
+                            "ITtscGraphDetails.IRequest": {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "details"
+                                        ],
+                                        description: "Discriminator for selected symbol inspection."
+                                    },
+                                    dependencyLimit: {
+                                        type: "number",
+                                        description: "Maximum direct execution and type references to return per group. Raise\nonly when the first dependency slice is truncated and the missing\ndependency is named."
+                                    },
+                                    handles: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Node ids from another tool, or dotted symbol handles such as\n`OrderService.create`. Pass the few handles you need for source-free\ndetails. Prefer one to three handles. Use `trace` when you need a path\ninstead of widening this call."
+                                    },
+                                    includeExternal: {
+                                        type: "boolean",
+                                        description: "Include dependency-boundary references from node_modules or bundled\n`.d.ts` libraries. Leave false for source-architecture answers; enable\nonly when external type/API boundaries are the question."
+                                    },
+                                    memberLimit: {
+                                        type: "number",
+                                        description: "Maximum owned members to return for a container or object literal. Raise\nonly when the first outline is truncated and the missing member is\nnamed."
+                                    },
+                                    neighborLimit: {
+                                        type: "number",
+                                        description: "Maximum dependencies and dependents to return per side when\n`neighbors:true`.\n\nPrefer the default. Values above a few neighbors are usually overfetch;\ncall `trace` for flow instead."
+                                    },
+                                    neighbors: {
+                                        type: "boolean",
+                                        description: "Also list each node's direct dependencies and dependents (the symbols it\nuses and the symbols that use it). The list is capped; raise\n`neighborLimit` when the first slice is truncated and the missing\nrelation is named. This remains a relationship summary, not a file body."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "handles"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphEntrypoints.IRequest": {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "entrypoints"
+                                        ],
+                                        description: "Discriminator for first-pass question indexing."
+                                    },
+                                    limit: {
+                                        type: "number",
+                                        description: "Maximum ranked hits to return.\n\nPrefer the default. Raise only when the first result was truncated and\nthe missing handle is named."
+                                    },
+                                    neighbors: {
+                                        type: "number",
+                                        description: "Maximum direct dependencies and dependents to return per indexed symbol.\nThis is an orientation slice, not a dependency dump; use `trace` or\n`details` with `neighbors:true` after choosing the specific handles.\nPrefer the default zero for the first call."
+                                    },
+                                    query: {
+                                        type: "string",
+                                        description: "A natural code question or search phrase. Mix prose with code handles,\nfor example `how Repository.find loads relations` or\n`SelectQueryBuilder.setFindOptions join aliases`. Keep this close to the\nuser's question; do not turn it into a broad keyword dump."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "query"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphEscape.IRequest": {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "escape"
+                                        ],
+                                        description: "Discriminator for the no-op escape route."
+                                    },
+                                    nextStep: {
+                                        type: "string",
+                                        description: "The final non-graph note, if useful.\n\nKeep this short. Examples: `answer from the prior graph result`, `source\nbody needed at returned sourceSpan`, or `ask the user for a concrete\nsymbol`."
+                                    },
+                                    reason: {
+                                        type: "string",
+                                        description: "Why no graph operation should run.\n\nUse this only when the next evidence is outside the indexed TypeScript\ngraph: package scripts, config files, generated output, prose docs, exact\ntext, or exact source body text. Name the smallest returned sourceSpan\nwhen source body text is truly required."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "reason"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphLookup.IRequest": {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "lookup"
+                                        ],
+                                        description: "Discriminator for targeted symbol lookup."
+                                    },
+                                    includeExternal: {
+                                        type: "boolean",
+                                        description: "Include dependency-boundary declarations from node_modules or bundled\n`.d.ts` libraries. Leave false for project-source answers; enable only\nwhen external type/API boundaries are the question."
+                                    },
+                                    limit: {
+                                        type: "number",
+                                        description: "Maximum hits to return.\n\nPrefer the default. Large hit lists usually mean the query is too broad;\nrefine the name instead of raising this."
+                                    },
+                                    query: {
+                                        type: "string",
+                                        description: "What to find, in natural language and code vocabulary mixed freely: a\nsymbol name, a dotted member (`Service.create`), or a short phrase\n(`request handler`). Exact names are not required, but this is not a\nsecond broad entrypoints call. Use it when a named handle is missing or\nambiguous."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "query"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphOverview.IRequest": {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "overview"
+                                        ],
+                                        description: "Discriminator for source-free project overview."
+                                    },
+                                    aspect: {
+                                        type: "string",
+                                        "enum": [
+                                            "all",
+                                            "hotspots",
+                                            "layers",
+                                            "publicApi"
+                                        ],
+                                        description: "The facet to project, or `all` for every facet. `layers` is the folder\nlayering, `hotspots` the highest-dependency symbols, `publicApi` the\nexported API symbols ranked by how depended-on they are.\n\nUse this only for broad public API or layer orientation. For behavior,\nlifecycle, request-flow, rendering-flow, validation-flow, caller, or\ndependency questions, use `entrypoints` then `trace` instead."
+                                    }
+                                },
+                                required: [
+                                    "type"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphTour.IRequest": {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "tour"
+                                        ],
+                                        description: "Discriminator for code-tour indexing."
+                                    },
+                                    includeTests: {
+                                        type: "boolean",
+                                        description: "Include graph-reached test or usage anchors when available."
+                                    },
+                                    limit: {
+                                        type: "number",
+                                        description: "Maximum central entrypoints to seed the tour.\n\nPrefer the default. Raise only when the question names several distinct\npublic paths that must all appear in one answer."
+                                    },
+                                    query: {
+                                        type: "string",
+                                        description: "The user's natural code-tour question."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "query"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphTrace.IRequest": {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "trace"
+                                        ],
+                                        description: "Discriminator for dependency tracing."
+                                    },
+                                    direction: {
+                                        type: "string",
+                                        "enum": [
+                                            "forward",
+                                            "impact",
+                                            "reverse"
+                                        ],
+                                        description: "`forward` follows what the start uses (callees, instantiations, renders);\n`reverse` follows what uses the start (callers); `impact` is a reverse\ntrace that prioritizes public API and test nodes a change would reach.\nIts test nodes are semantic usage edges, not a text-search inventory.\nCaller questions usually fit `reverse`."
+                                    },
+                                    focus: {
+                                        type: "string",
+                                        "enum": [
+                                            "all",
+                                            "execution",
+                                            "types"
+                                        ],
+                                        description: "Which non-structural edge family to follow: `execution` follows runtime\ncalls, instantiations, property access, and JSX renders; `types` follows\ntype references and inheritance; `all` preserves the full graph. Flow\nquestions should usually choose `execution` rather than `all`."
+                                    },
+                                    from: {
+                                        type: "string",
+                                        description: "Where to start: a node id from another tool, a simple symbol name, or a\ndotted member name such as `OrderService.create`. An ambiguous name\nreturns its candidates instead of a trace."
+                                    },
+                                    includeExternal: {
+                                        type: "boolean",
+                                        description: "Include dependency-boundary nodes from node_modules or bundled `.d.ts`\nlibraries. Leave false for source-flow tours; enable only when the user\nasks about external type/API boundaries."
+                                    },
+                                    maxDepth: {
+                                        type: "number",
+                                        description: "How many hops deep to follow. Open forward/reverse traces are capped at\n2; impact traces at 4; path mode at 12.\n\nPrefer the default for open traces. Raise only for path mode or when the\nprevious trace named the missing next hop."
+                                    },
+                                    maxNodes: {
+                                        type: "number",
+                                        description: "Cap on reached nodes; the trace stops and marks itself truncated past it.\nOpen forward/reverse traces are capped at 8 nodes, impact at 16 nodes.\n\nPrefer the default; use larger open traces only when a named missing edge\nrequires it."
+                                    },
+                                    to: {
+                                        type: "string",
+                                        description: "A target symbol: node id, simple symbol name, or dotted member name. When\ngiven, the tool returns the dependency path from `from` to this target,\nthe one-call answer for \"how does A reach B\", instead of an open-ended\ntrace. Prefer this path mode whenever both ends are known."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "from"
+                                ],
+                                additionalProperties: false
+                            }
+                        }
                     },
                     validate: (() => {
-                        const _io0 = input => "string" === typeof input.from && (undefined === input.to || "string" === typeof input.to) && (undefined === input.direction || "forward" === input.direction || "impact" === input.direction || "reverse" === input.direction) && (undefined === input.maxDepth || "number" === typeof input.maxDepth) && (undefined === input.maxNodes || "number" === typeof input.maxNodes);
-                        const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.from || _report(_exceptionable, {
+                        const _io0 = input => "string" === typeof input.question && "string" === typeof input.draft && "string" === typeof input.review && ("object" === typeof input.request && null !== input.request && _iu0(input.request));
+                        const _io1 = input => "details" === input.type && (Array.isArray(input.handles) && input.handles.every(elem => "string" === typeof elem)) && (undefined === input.neighbors || "boolean" === typeof input.neighbors) && (undefined === input.neighborLimit || "number" === typeof input.neighborLimit) && (undefined === input.memberLimit || "number" === typeof input.memberLimit) && (undefined === input.dependencyLimit || "number" === typeof input.dependencyLimit) && (undefined === input.includeExternal || "boolean" === typeof input.includeExternal);
+                        const _io2 = input => "entrypoints" === input.type && "string" === typeof input.query && (undefined === input.limit || "number" === typeof input.limit) && (undefined === input.neighbors || "number" === typeof input.neighbors);
+                        const _io3 = input => "lookup" === input.type && "string" === typeof input.query && (undefined === input.limit || "number" === typeof input.limit) && (undefined === input.includeExternal || "boolean" === typeof input.includeExternal);
+                        const _io4 = input => "overview" === input.type && (undefined === input.aspect || "all" === input.aspect || "hotspots" === input.aspect || "layers" === input.aspect || "publicApi" === input.aspect);
+                        const _io5 = input => "tour" === input.type && "string" === typeof input.query && (undefined === input.limit || "number" === typeof input.limit) && (undefined === input.includeTests || "boolean" === typeof input.includeTests);
+                        const _io6 = input => "trace" === input.type && "string" === typeof input.from && (undefined === input.to || "string" === typeof input.to) && (undefined === input.direction || "forward" === input.direction || "impact" === input.direction || "reverse" === input.direction) && (undefined === input.focus || "all" === input.focus || "execution" === input.focus || "types" === input.focus) && (undefined === input.maxDepth || "number" === typeof input.maxDepth) && (undefined === input.maxNodes || "number" === typeof input.maxNodes) && (undefined === input.includeExternal || "boolean" === typeof input.includeExternal);
+                        const _io7 = input => "escape" === input.type && "string" === typeof input.reason && (undefined === input.nextStep || "string" === typeof input.nextStep);
+                        const _iu0 = input => (() => {
+                            if ("details" === input.type)
+                                return _io1(input);
+                            else if ("entrypoints" === input.type)
+                                return _io2(input);
+                            else if ("lookup" === input.type)
+                                return _io3(input);
+                            else if ("overview" === input.type)
+                                return _io4(input);
+                            else if ("tour" === input.type)
+                                return _io5(input);
+                            else if ("trace" === input.type)
+                                return _io6(input);
+                            else if ("escape" === input.type)
+                                return _io7(input);
+                            else
+                                return false;
+                        })();
+                        const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.question || _report(_exceptionable, {
+                                path: _path + ".question",
+                                expected: "string",
+                                value: input.question
+                            }), "string" === typeof input.draft || _report(_exceptionable, {
+                                path: _path + ".draft",
+                                expected: "string",
+                                value: input.draft
+                            }), "string" === typeof input.review || _report(_exceptionable, {
+                                path: _path + ".review",
+                                expected: "string",
+                                value: input.review
+                            }), ("object" === typeof input.request && null !== input.request || _report(_exceptionable, {
+                                path: _path + ".request",
+                                expected: "(ITtscGraphDetails.IRequest | ITtscGraphEntrypoints.IRequest | ITtscGraphEscape.IRequest | ITtscGraphLookup.IRequest | ITtscGraphOverview.IRequest | ITtscGraphTour.IRequest | ITtscGraphTrace.IRequest)",
+                                value: input.request
+                            })) && _vu0(input.request, _path + ".request", true && _exceptionable) || _report(_exceptionable, {
+                                path: _path + ".request",
+                                expected: "(ITtscGraphDetails.IRequest | ITtscGraphEntrypoints.IRequest | ITtscGraphEscape.IRequest | ITtscGraphLookup.IRequest | ITtscGraphOverview.IRequest | ITtscGraphTour.IRequest | ITtscGraphTrace.IRequest)",
+                                value: input.request
+                            })].every(flag => flag);
+                        const _vo1 = (input, _path, _exceptionable = true) => ["details" === input.type || _report(_exceptionable, {
+                                path: _path + ".type",
+                                expected: "\"details\"",
+                                value: input.type
+                            }), (Array.isArray(input.handles) || _report(_exceptionable, {
+                                path: _path + ".handles",
+                                expected: "Array<string>",
+                                value: input.handles
+                            })) && input.handles.map((elem, _index2) => "string" === typeof elem || _report(_exceptionable, {
+                                path: _path + ".handles[" + _index2 + "]",
+                                expected: "string",
+                                value: elem
+                            })).every(flag => flag) || _report(_exceptionable, {
+                                path: _path + ".handles",
+                                expected: "Array<string>",
+                                value: input.handles
+                            }), undefined === input.neighbors || "boolean" === typeof input.neighbors || _report(_exceptionable, {
+                                path: _path + ".neighbors",
+                                expected: "(boolean | undefined)",
+                                value: input.neighbors
+                            }), undefined === input.neighborLimit || "number" === typeof input.neighborLimit || _report(_exceptionable, {
+                                path: _path + ".neighborLimit",
+                                expected: "(number | undefined)",
+                                value: input.neighborLimit
+                            }), undefined === input.memberLimit || "number" === typeof input.memberLimit || _report(_exceptionable, {
+                                path: _path + ".memberLimit",
+                                expected: "(number | undefined)",
+                                value: input.memberLimit
+                            }), undefined === input.dependencyLimit || "number" === typeof input.dependencyLimit || _report(_exceptionable, {
+                                path: _path + ".dependencyLimit",
+                                expected: "(number | undefined)",
+                                value: input.dependencyLimit
+                            }), undefined === input.includeExternal || "boolean" === typeof input.includeExternal || _report(_exceptionable, {
+                                path: _path + ".includeExternal",
+                                expected: "(boolean | undefined)",
+                                value: input.includeExternal
+                            })].every(flag => flag);
+                        const _vo2 = (input, _path, _exceptionable = true) => ["entrypoints" === input.type || _report(_exceptionable, {
+                                path: _path + ".type",
+                                expected: "\"entrypoints\"",
+                                value: input.type
+                            }), "string" === typeof input.query || _report(_exceptionable, {
+                                path: _path + ".query",
+                                expected: "string",
+                                value: input.query
+                            }), undefined === input.limit || "number" === typeof input.limit || _report(_exceptionable, {
+                                path: _path + ".limit",
+                                expected: "(number | undefined)",
+                                value: input.limit
+                            }), undefined === input.neighbors || "number" === typeof input.neighbors || _report(_exceptionable, {
+                                path: _path + ".neighbors",
+                                expected: "(number | undefined)",
+                                value: input.neighbors
+                            })].every(flag => flag);
+                        const _vo3 = (input, _path, _exceptionable = true) => ["lookup" === input.type || _report(_exceptionable, {
+                                path: _path + ".type",
+                                expected: "\"lookup\"",
+                                value: input.type
+                            }), "string" === typeof input.query || _report(_exceptionable, {
+                                path: _path + ".query",
+                                expected: "string",
+                                value: input.query
+                            }), undefined === input.limit || "number" === typeof input.limit || _report(_exceptionable, {
+                                path: _path + ".limit",
+                                expected: "(number | undefined)",
+                                value: input.limit
+                            }), undefined === input.includeExternal || "boolean" === typeof input.includeExternal || _report(_exceptionable, {
+                                path: _path + ".includeExternal",
+                                expected: "(boolean | undefined)",
+                                value: input.includeExternal
+                            })].every(flag => flag);
+                        const _vo4 = (input, _path, _exceptionable = true) => ["overview" === input.type || _report(_exceptionable, {
+                                path: _path + ".type",
+                                expected: "\"overview\"",
+                                value: input.type
+                            }), undefined === input.aspect || "all" === input.aspect || "hotspots" === input.aspect || "layers" === input.aspect || "publicApi" === input.aspect || _report(_exceptionable, {
+                                path: _path + ".aspect",
+                                expected: "(\"all\" | \"hotspots\" | \"layers\" | \"publicApi\" | undefined)",
+                                value: input.aspect
+                            })].every(flag => flag);
+                        const _vo5 = (input, _path, _exceptionable = true) => ["tour" === input.type || _report(_exceptionable, {
+                                path: _path + ".type",
+                                expected: "\"tour\"",
+                                value: input.type
+                            }), "string" === typeof input.query || _report(_exceptionable, {
+                                path: _path + ".query",
+                                expected: "string",
+                                value: input.query
+                            }), undefined === input.limit || "number" === typeof input.limit || _report(_exceptionable, {
+                                path: _path + ".limit",
+                                expected: "(number | undefined)",
+                                value: input.limit
+                            }), undefined === input.includeTests || "boolean" === typeof input.includeTests || _report(_exceptionable, {
+                                path: _path + ".includeTests",
+                                expected: "(boolean | undefined)",
+                                value: input.includeTests
+                            })].every(flag => flag);
+                        const _vo6 = (input, _path, _exceptionable = true) => ["trace" === input.type || _report(_exceptionable, {
+                                path: _path + ".type",
+                                expected: "\"trace\"",
+                                value: input.type
+                            }), "string" === typeof input.from || _report(_exceptionable, {
                                 path: _path + ".from",
                                 expected: "string",
                                 value: input.from
@@ -1125,6 +1917,10 @@ function createServer(graph, version) {
                                 path: _path + ".direction",
                                 expected: "(\"forward\" | \"impact\" | \"reverse\" | undefined)",
                                 value: input.direction
+                            }), undefined === input.focus || "all" === input.focus || "execution" === input.focus || "types" === input.focus || _report(_exceptionable, {
+                                path: _path + ".focus",
+                                expected: "(\"all\" | \"execution\" | \"types\" | undefined)",
+                                value: input.focus
                             }), undefined === input.maxDepth || "number" === typeof input.maxDepth || _report(_exceptionable, {
                                 path: _path + ".maxDepth",
                                 expected: "(number | undefined)",
@@ -1133,7 +1929,46 @@ function createServer(graph, version) {
                                 path: _path + ".maxNodes",
                                 expected: "(number | undefined)",
                                 value: input.maxNodes
+                            }), undefined === input.includeExternal || "boolean" === typeof input.includeExternal || _report(_exceptionable, {
+                                path: _path + ".includeExternal",
+                                expected: "(boolean | undefined)",
+                                value: input.includeExternal
                             })].every(flag => flag);
+                        const _vo7 = (input, _path, _exceptionable = true) => ["escape" === input.type || _report(_exceptionable, {
+                                path: _path + ".type",
+                                expected: "\"escape\"",
+                                value: input.type
+                            }), "string" === typeof input.reason || _report(_exceptionable, {
+                                path: _path + ".reason",
+                                expected: "string",
+                                value: input.reason
+                            }), undefined === input.nextStep || "string" === typeof input.nextStep || _report(_exceptionable, {
+                                path: _path + ".nextStep",
+                                expected: "(string | undefined)",
+                                value: input.nextStep
+                            })].every(flag => flag);
+                        const _vu0 = (input, _path, _exceptionable = true) => (() => {
+                            if ("details" === input.type)
+                                return _vo1(input, _path, true && _exceptionable);
+                            else if ("entrypoints" === input.type)
+                                return _vo2(input, _path, true && _exceptionable);
+                            else if ("lookup" === input.type)
+                                return _vo3(input, _path, true && _exceptionable);
+                            else if ("overview" === input.type)
+                                return _vo4(input, _path, true && _exceptionable);
+                            else if ("tour" === input.type)
+                                return _vo5(input, _path, true && _exceptionable);
+                            else if ("trace" === input.type)
+                                return _vo6(input, _path, true && _exceptionable);
+                            else if ("escape" === input.type)
+                                return _vo7(input, _path, true && _exceptionable);
+                            else
+                                return _report(_exceptionable, {
+                                    path: _path,
+                                    expected: "(ITtscGraphDetails.IRequest | ITtscGraphEntrypoints.IRequest | ITtscGraphLookup.IRequest | ITtscGraphOverview.IRequest | ITtscGraphTour.IRequest | ITtscGraphTrace.IRequest | ITtscGraphEscape.IRequest)",
+                                    value: input
+                                });
+                        })();
                         const __is = input => "object" === typeof input && null !== input && _io0(input);
                         let errors;
                         let _report;
@@ -1143,11 +1978,11 @@ function createServer(graph, version) {
                                 _report = _b._validateReport(errors);
                                 ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
                                     path: _path + "",
-                                    expected: "ITtscGraphTrace.IProps",
+                                    expected: "ITtscGraphApplication.IProps",
                                     value: input
                                 })) && _vo0(input, _path + "", true) || _report(true, {
                                     path: _path + "",
-                                    expected: "ITtscGraphTrace.IProps",
+                                    expected: "ITtscGraphApplication.IProps",
                                     value: input
                                 }))(input, "$input", true);
                                 const success = 0 === errors.length;
@@ -1193,8 +2028,8 @@ function createServer(graph, version) {
         if (func === undefined || method === undefined) {
             return error(`Unknown tool: ${request.params.name}`);
         }
-        // A client may omit `arguments` for an all-optional tool (e.g. graph_overview);
-        // validate an empty object so that call succeeds instead of failing on "expected object".
+        // Validate an empty object when a client omits `arguments`, so typia can
+        // return field-level errors instead of a generic "expected object".
         const validation = func.validate(request.params.arguments ?? {});
         if (!validation.success) {
             // Hand typia's validation errors back so the model can correct its call.
@@ -1206,9 +2041,7 @@ function createServer(graph, version) {
                 content: [
                     {
                         type: "text",
-                        text: result === undefined
-                            ? "Success"
-                            : JSON.stringify(result, null, 2),
+                        text: result === undefined ? "Success" : JSON.stringify(result),
                     },
                 ],
             };