@ttsc/graph 0.16.5 → 0.16.6

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,57 +66,351 @@ 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: "Query the TypeScript project graph for code evidence.\n\nUse this before answering TypeScript codebase questions. It returns\nchecker-resolved symbols, dependency paths, edge evidence ranges, and\nsourceSpan anchors from the resident graph, avoiding assumptions, shell\nsearch, or file reads when graph evidence is enough.\n\nFill properties in order: question, graphNeed, draft, review, request.\nWrite `draft.reason` before `draft.type`, then choose `entrypoints`,\n`lookup`, `trace`, `details`, `overview`, or `escape`.\n\nMost answers should need 1-3 calls; four is the hard stop for one answer.\nKeep slices small, prefer defaults, and stop once file/symbol/range\nevidence is enough.",
+                    name: "query",
                     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/ITtscGraphTrace"
+                                    }
+                                ],
+                                "x-discriminator": {
+                                    mapping: {
+                                        details: "#/$defs/ITtscGraphDetails",
+                                        entrypoints: "#/$defs/ITtscGraphEntrypoints",
+                                        escape: "#/$defs/ITtscGraphEscape",
+                                        lookup: "#/$defs/ITtscGraphLookup",
+                                        overview: "#/$defs/ITtscGraphOverview",
+                                        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."
+                                    },
+                                    nodes: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDetails.INode"
+                                        }
+                                    },
+                                    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."
+                                required: [
+                                    "type",
+                                    "nodes",
+                                    "unknown"
+                                ],
+                                additionalProperties: false
                             },
-                            next: {
-                                $ref: "#/$defs/ITtscGraphIndex.INext",
-                                description: "Follow-up handles for deeper graph calls."
+                            "ITtscGraphDetails.IMember": {
+                                type: "object",
+                                properties: {
+                                    decorators: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDecorator"
+                                        },
+                                        description: "Decorators written on this member, when any."
+                                    },
+                                    kind: {
+                                        type: "string"
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    name: {
+                                        type: "string"
+                                    },
+                                    signature: {
+                                        type: "string",
+                                        description: "The member's declaration signature."
+                                    }
+                                },
+                                required: [
+                                    "name",
+                                    "kind"
+                                ],
+                                additionalProperties: false
                             },
-                            query: {
-                                type: "string",
-                                description: "The original query the index was built for."
+                            "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"
+                                    },
+                                    id: {
+                                        type: "string"
+                                    },
+                                    implementation: {
+                                        $ref: "#/$defs/ITtscGraphEvidence",
+                                        description: "Assigned implementation span, when source comes from one."
+                                    },
+                                    kind: {
+                                        type: "string"
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    literals: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "String literal values from the signature."
+                                    },
+                                    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"
+                                    },
+                                    signature: {
+                                        type: "string",
+                                        description: "The declaration signature: its first line(s) up to the body."
+                                    },
+                                    sourceSpan: {
+                                        $ref: "#/$defs/PickITtscGraphEvidenceendLinefilestartLine",
+                                        description: "The declaration or implementation file and line 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"
+                                ],
+                                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.IReference": {
+                                type: "object",
+                                properties: {
+                                    aliases: {
+                                        type: "array",
+                                        items: {
+                                            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."
+                                    },
+                                    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"
+                                    },
+                                    id: {
+                                        type: "string"
+                                    },
+                                    kind: {
+                                        type: "string"
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    name: {
+                                        type: "string"
+                                    },
+                                    relation: {
+                                        type: "string",
+                                        description: "The edge kind connecting the two (`calls`, `type_ref`, ...)."
+                                    }
+                                },
+                                required: [
+                                    "id",
+                                    "name",
+                                    "kind",
+                                    "file",
+                                    "relation"
+                                ],
+                                additionalProperties: false
+                            },
+                            ITtscGraphEntrypoints: {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "entrypoints"
+                                        ],
+                                        description: "Discriminator for first-pass question indexing."
+                                    },
+                                    hits: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphEntrypoints.IHit"
+                                        },
+                                        description: "Ranked symbols relevant to the query."
+                                    },
+                                    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/ITtscGraphEntrypoints.INext",
+                                        description: "Follow-up handles for deeper graph calls."
+                                    },
+                                    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"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphEntrypoints.IHit": {
                                 type: "object",
                                 properties: {
+                                    decorators: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDecorator"
+                                        },
+                                        description: "Decorators written on this declaration, when any."
+                                    },
                                     file: {
                                         type: "string"
                                     },
@@ -151,20 +445,20 @@ function createServer(graph, version) {
                                 ],
                                 additionalProperties: false
                             },
-                            "ITtscGraphIndex.IMention": {
+                            "ITtscGraphEntrypoints.IMention": {
                                 type: "object",
                                 properties: {
                                     candidates: {
                                         type: "array",
                                         items: {
-                                            $ref: "#/$defs/ITtscGraphIndex.INode"
+                                            $ref: "#/$defs/ITtscGraphEntrypoints.INode"
                                         }
                                     },
                                     handle: {
                                         type: "string"
                                     },
                                     node: {
-                                        $ref: "#/$defs/ITtscGraphIndex.INode"
+                                        $ref: "#/$defs/ITtscGraphEntrypoints.INode"
                                     }
                                 },
                                 required: [
@@ -172,19 +466,26 @@ function createServer(graph, version) {
                                 ],
                                 additionalProperties: false
                             },
-                            "ITtscGraphIndex.INeighborhood": {
+                            "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/ITtscGraphIndex.IReference"
+                                            $ref: "#/$defs/ITtscGraphEntrypoints.IReference"
                                         }
                                     },
                                     dependsOn: {
                                         type: "array",
                                         items: {
-                                            $ref: "#/$defs/ITtscGraphIndex.IReference"
+                                            $ref: "#/$defs/ITtscGraphEntrypoints.IReference"
                                         }
                                     },
                                     file: {
@@ -218,33 +519,40 @@ function createServer(graph, version) {
                                 ],
                                 additionalProperties: false
                             },
-                            "ITtscGraphIndex.INext": {
+                            "ITtscGraphEntrypoints.INext": {
                                 type: "object",
                                 properties: {
-                                    expand: {
+                                    details: {
                                         type: "array",
                                         items: {
                                             type: "string"
                                         },
-                                        description: "Pass these ids to `graph_expand`, with `source: true` only when needed."
+                                        description: "Pass these ids to `details` for source-free symbol facts."
                                     },
                                     traceFrom: {
                                         type: "array",
                                         items: {
                                             type: "string"
                                         },
-                                        description: "Pass these ids to `graph_trace` when following dependency flow."
+                                        description: "Pass these ids to `trace` when following dependency flow."
                                     }
                                 },
                                 required: [
-                                    "expand",
+                                    "details",
                                     "traceFrom"
                                 ],
                                 additionalProperties: false
                             },
-                            "ITtscGraphIndex.INode": {
+                            "ITtscGraphEntrypoints.INode": {
                                 type: "object",
                                 properties: {
+                                    decorators: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphDecorator"
+                                        },
+                                        description: "Decorators written on this declaration, when any."
+                                    },
                                     file: {
                                         type: "string"
                                     },
@@ -274,9 +582,13 @@ function createServer(graph, version) {
                                 ],
                                 additionalProperties: false
                             },
-                            "ITtscGraphIndex.IReference": {
+                            "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"
                                     },
@@ -305,121 +617,213 @@ function createServer(graph, version) {
                                     "relation"
                                 ],
                                 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."
+                            ITtscGraphEscape: {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "escape"
+                                        ],
+                                        description: "Discriminator for the no-op escape route."
+                                    },
+                                    nextStep: {
+                                        type: "string",
+                                        description: "The next non-graph step, if useful."
+                                    },
+                                    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"
+                                ],
+                                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."
+                            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."
+                                    },
+                                    hits: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphLookup.IHit"
+                                        }
+                                    },
+                                    next: {
+                                        $ref: "#/$defs/ITtscGraphLookup.INext",
+                                        description: "Follow-up handles for selected symbol details."
+                                    }
                                 },
-                                description: "Highest-dependency symbols, busiest first."
+                                required: [
+                                    "type",
+                                    "hits",
+                                    "next"
+                                ],
+                                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"
+                                    },
+                                    id: {
+                                        type: "string"
+                                    },
+                                    kind: {
+                                        type: "string"
+                                    },
+                                    line: {
+                                        type: "number",
+                                        description: "1-based declaration line, when known."
+                                    },
+                                    name: {
+                                        type: "string"
+                                    },
+                                    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."
+                            "ITtscGraphLookup.INext": {
+                                type: "object",
+                                properties: {
+                                    details: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Pass these ids to `details` for source-free symbol facts."
+                                    },
+                                    traceFrom: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Pass these ids to `trace` when following dependency flow."
+                                    }
+                                },
+                                required: [
+                                    "details",
+                                    "traceFrom"
+                                ],
+                                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."
+                                    },
+                                    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."
+                                    },
+                                    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"
+                                ],
+                                additionalProperties: false
+                            },
                             "ITtscGraphOverview.ICounts": {
                                 type: "object",
                                 properties: {
@@ -457,16 +861,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,342 +914,179 @@ 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": {
+                            ITtscGraphTrace: {
                                 type: "object",
                                 properties: {
-                                    kind: {
-                                        type: "string"
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "trace"
+                                        ],
+                                        description: "Discriminator for dependency tracing."
                                     },
-                                    line: {
-                                        type: "number",
-                                        description: "1-based declaration line, when known."
+                                    candidates: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/$defs/ITtscGraphTrace.INode"
+                                        },
+                                        description: "When `from` was an ambiguous name, the matches to disambiguate with."
                                     },
-                                    name: {
+                                    direction: {
                                         type: "string"
                                     },
-                                    signature: {
-                                        type: "string",
-                                        description: "The member's declaration signature."
-                                    }
-                                },
-                                required: [
-                                    "name",
-                                    "kind"
-                                ],
-                                additionalProperties: false
-                            },
-                            "ITtscGraphExpand.INode": {
-                                type: "object",
-                                properties: {
-                                    dependedOnBy: {
+                                    hops: {
                                         type: "array",
                                         items: {
-                                            $ref: "#/$defs/ITtscGraphExpand.IReference"
+                                            $ref: "#/$defs/ITtscGraphTrace.IHop"
                                         },
-                                        description: "Symbols that use this node (incoming dependency edges)."
+                                        description: "Edges traversed, in breadth-first order."
                                     },
-                                    dependsOn: {
+                                    next: {
+                                        $ref: "#/$defs/ITtscGraphTrace.INext",
+                                        description: "Follow-up handles for inspecting or continuing the trace."
+                                    },
+                                    path: {
                                         type: "array",
                                         items: {
-                                            $ref: "#/$defs/ITtscGraphExpand.IReference"
+                                            $ref: "#/$defs/ITtscGraphTrace.INode"
                                         },
-                                        description: "Symbols this node uses (outgoing dependency edges)."
-                                    },
-                                    file: {
-                                        type: "string"
-                                    },
-                                    id: {
-                                        type: "string"
-                                    },
-                                    kind: {
-                                        type: "string"
-                                    },
-                                    line: {
-                                        type: "number",
-                                        description: "1-based declaration line, when known."
+                                        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`."
                                     },
-                                    members: {
+                                    reached: {
                                         type: "array",
                                         items: {
-                                            $ref: "#/$defs/ITtscGraphExpand.IMember"
+                                            $ref: "#/$defs/ITtscGraphTrace.INode"
                                         },
-                                        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."
+                                        description: "Unique nodes reached (excluding the start), each with its depth and roles."
                                     },
-                                    name: {
-                                        type: "string"
+                                    start: {
+                                        $ref: "#/$defs/ITtscGraphTrace.INode",
+                                        description: "The resolved start node, or undefined when `from` matched nothing."
                                     },
-                                    signature: {
-                                        type: "string",
-                                        description: "The declaration signature \u2014 its first line(s) up to the body."
+                                    steps: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Compact hop summaries preserving node names and edge evidence, capped."
                                     },
-                                    source: {
-                                        type: "string",
-                                        description: "The full declaration source \u2014 only when `source` was requested."
+                                    target: {
+                                        $ref: "#/$defs/ITtscGraphTrace.INode",
+                                        description: "The resolved `to` target, when a path was requested."
                                     },
                                     truncated: {
                                         type: "boolean",
-                                        description: "True when `source` was cut at the line cap."
+                                        description: "True when the trace hit maxNodes or maxDepth and more flow exists."
                                     }
                                 },
                                 required: [
-                                    "id",
-                                    "name",
-                                    "kind",
-                                    "file"
+                                    "type",
+                                    "direction",
+                                    "hops",
+                                    "reached",
+                                    "truncated"
                                 ],
                                 additionalProperties: false
                             },
-                            "ITtscGraphExpand.IReference": {
+                            "ITtscGraphTrace.IHop": {
                                 type: "object",
                                 properties: {
-                                    id: {
+                                    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 lets an agent\nexplain why the trace moves from one symbol to the next without opening\nthe file."
+                                    },
+                                    from: {
                                         type: "string"
                                     },
                                     kind: {
                                         type: "string"
                                     },
-                                    name: {
+                                    to: {
                                         type: "string"
-                                    },
-                                    relation: {
-                                        type: "string",
-                                        description: "The edge kind connecting the two (`calls`, `type_ref`, \u2026)."
                                     }
                                 },
                                 required: [
-                                    "id",
-                                    "name",
+                                    "from",
+                                    "to",
                                     "kind",
-                                    "relation"
+                                    "depth"
                                 ],
                                 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"
-                                }
+                            "ITtscGraphTrace.INext": {
+                                type: "object",
+                                properties: {
+                                    details: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Pass these ids to `details` for selected symbol details."
+                                    },
+                                    traceFrom: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Continue tracing from these ids when the current result is intermediate."
+                                    }
+                                },
+                                required: [
+                                    "details",
+                                    "traceFrom"
+                                ],
+                                additionalProperties: false
                             },
-                            next: {
-                                $ref: "#/$defs/ITtscGraphQuery.INext",
-                                description: "Follow-up handles for source or member details."
-                            }
-                        },
-                        required: [
-                            "hits",
-                            "next"
-                        ],
-                        additionalProperties: false,
-                        $defs: {
-                            "ITtscGraphQuery.IHit": {
+                            "ITtscGraphTrace.INode": {
                                 type: "object",
                                 properties: {
+                                    depth: {
+                                        type: "number",
+                                        description: "Hops from the start, on a reached node."
+                                    },
                                     file: {
                                         type: "string"
                                     },
@@ -847,273 +1096,488 @@ function createServer(graph, version) {
                                     kind: {
                                         type: "string"
                                     },
-                                    line: {
-                                        type: "number",
-                                        description: "1-based declaration line, when known."
-                                    },
                                     name: {
                                         type: "string"
                                     },
-                                    score: {
-                                        type: "number",
-                                        description: "Relative relevance; higher is a better match."
+                                    roles: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        },
+                                        description: "Why this node matters to an impact trace: `exported`, `test`."
                                     },
                                     signature: {
                                         type: "string",
-                                        description: "The hit's declaration signature, so you can often answer without\nexpanding."
+                                        description: "The node's signature, carried on path nodes so the path explains itself."
                                     }
                                 },
                                 required: [
                                     "id",
                                     "name",
                                     "kind",
-                                    "file",
-                                    "score"
+                                    "file"
                                 ],
                                 additionalProperties: false
                             },
-                            "ITtscGraphQuery.INext": {
+                            PickITtscGraphEvidenceendLinefilestartLine: {
                                 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 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: [
-                                    "expand"
+                                    "file",
+                                    "startLine"
                                 ],
                                 additionalProperties: false
+                            },
+                            Recordstringnumber: {
+                                type: "object",
+                                properties: {},
+                                required: [],
+                                additionalProperties: {
+                                    type: "number"
+                                }
                             }
                         }
                     },
                     parameters: {
                         type: "object",
                         properties: {
-                            limit: {
-                                type: "number",
-                                description: "Maximum hits to return."
+                            draft: {
+                                $ref: "#/$defs/ITtscGraphApplication.IRequestDraft",
+                                description: "First request-type decision before arguments are filled.\n\nExplain why one operation class is smaller than the alternatives, then\nname it in `draft.type`. This is only the draft; the final arguments are\nin `request` after `review`."
                             },
-                            query: {
+                            graphNeed: {
                                 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."
+                                description: "Why the resident graph is the next evidence source.\n\nState what graph evidence is needed and why assumptions or broad shell\nsearch are not the next step for this call. Name the smallest evidence\nthat would let the agent stop. If graph is not actually the right source,\nsay that and use `escape`."
                             },
-                            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."
+                            question: {
+                                type: "string",
+                                description: "User's TypeScript code question.\n\nRestate the codebase question being answered. Keep this about TypeScript\nsource, symbols, call flow, type flow, or architecture. If the user is\nasking about scripts, config, generated output, or documentation instead,\nsay that boundary here."
                             },
-                            target: {
-                                $ref: "#/$defs/ITtscGraphTrace.INode",
-                                description: "The resolved `to` target, when a path was requested."
+                            request: {
+                                anyOf: [
+                                    {
+                                        $ref: "#/$defs/ITtscGraphDetails.IRequest"
+                                    },
+                                    {
+                                        $ref: "#/$defs/ITtscGraphEntrypoints.IRequest"
+                                    },
+                                    {
+                                        $ref: "#/$defs/ITtscGraphLookup.IRequest"
+                                    },
+                                    {
+                                        $ref: "#/$defs/ITtscGraphOverview.IRequest"
+                                    },
+                                    {
+                                        $ref: "#/$defs/ITtscGraphTrace.IRequest"
+                                    },
+                                    {
+                                        $ref: "#/$defs/ITtscGraphEscape.IRequest"
+                                    }
+                                ],
+                                description: "The graph operation chosen from the reasoning above, 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",
+                                        trace: "#/$defs/ITtscGraphTrace.IRequest"
+                                    },
+                                    propertyName: "type"
+                                }
                             },
-                            truncated: {
-                                type: "boolean",
-                                description: "True when the trace hit maxNodes or maxDepth and more flow exists."
+                            review: {
+                                type: "string",
+                                description: "Critical review of the draft request.\n\nCheck whether the draft avoids overfetch, non-graph fallback, broad\nreads, and unnecessary neighbor expansion. If this would be a fourth\nbroad lookup, trace, or details call, prefer answering from evidence in\nhand or choose `escape`. Do not spend graph calls only to hunt for tests.\nIf the draft is wrong, choose the corrected type in `request`."
                             }
                         },
                         required: [
-                            "direction",
-                            "hops",
-                            "reached",
-                            "truncated"
+                            "question",
+                            "graphNeed",
+                            "draft",
+                            "review",
+                            "request"
                         ],
                         additionalProperties: false,
                         $defs: {
-                            "ITtscGraphTrace.IHop": {
+                            "ITtscGraphApplication.IRequestDraft": {
                                 type: "object",
                                 properties: {
-                                    depth: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "details",
+                                            "entrypoints",
+                                            "escape",
+                                            "lookup",
+                                            "overview",
+                                            "trace"
+                                        ],
+                                        description: "Draft discriminator for the intended graph operation."
+                                    },
+                                    reason: {
+                                        type: "string",
+                                        description: "Why this operation type is the smallest useful next step."
+                                    }
+                                },
+                                required: [
+                                    "reason",
+                                    "type"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphDetails.IRequest": {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "details"
+                                        ],
+                                        description: "Discriminator for selected symbol inspection."
+                                    },
+                                    dependencyLimit: {
                                         type: "number",
-                                        description: "Hops from the start (1 = direct)."
+                                        description: "Maximum direct execution and type references to return per group. Raise\nonly when the first dependency slice is not enough."
                                     },
-                                    from: {
-                                        type: "string"
+                                    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; use `trace` when you need a path instead of widening this call."
                                     },
-                                    kind: {
-                                        type: "string"
+                                    memberLimit: {
+                                        type: "number",
+                                        description: "Maximum owned members to return for a container or object literal. Raise\nonly when the first outline is truncated."
                                     },
-                                    to: {
-                                        type: "string"
+                                    neighborLimit: {
+                                        type: "number",
+                                        description: "Maximum dependencies and dependents to return per side when\n`neighbors:true`."
+                                    },
+                                    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` only when the first slice is not enough."
                                     }
                                 },
                                 required: [
-                                    "from",
-                                    "to",
-                                    "kind",
-                                    "depth"
+                                    "type",
+                                    "handles"
                                 ],
                                 additionalProperties: false
                             },
-                            "ITtscGraphTrace.INode": {
+                            "ITtscGraphEntrypoints.IRequest": {
                                 type: "object",
                                 properties: {
-                                    depth: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "entrypoints"
+                                        ],
+                                        description: "Discriminator for first-pass question indexing."
+                                    },
+                                    limit: {
                                         type: "number",
-                                        description: "Hops from the start, on a reached node."
+                                        description: "Maximum ranked hits to return."
                                     },
-                                    file: {
-                                        type: "string"
+                                    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."
                                     },
-                                    id: {
-                                        type: "string"
+                                    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: [
+                                    "type",
+                                    "query"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphEscape.IRequest": {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "escape"
+                                        ],
+                                        description: "Discriminator for the no-op escape route."
                                     },
-                                    kind: {
-                                        type: "string"
+                                    nextStep: {
+                                        type: "string",
+                                        description: "The next non-graph step, if useful.\n\nKeep this short. Examples: `answer from the prior graph result`, `inspect\npackage.json`, or `ask the user for a concrete symbol`."
                                     },
-                                    name: {
-                                        type: "string"
+                                    reason: {
+                                        type: "string",
+                                        description: "Why no graph operation should run.\n\nUse this when the review finds the user is asking about package scripts,\nconfig files, generated output, prose documentation, or an answer that\nthe current graph result already settled."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "reason"
+                                ],
+                                additionalProperties: false
+                            },
+                            "ITtscGraphLookup.IRequest": {
+                                type: "object",
+                                properties: {
+                                    type: {
+                                        type: "string",
+                                        "enum": [
+                                            "lookup"
+                                        ],
+                                        description: "Discriminator for targeted symbol lookup."
                                     },
-                                    roles: {
-                                        type: "array",
-                                        items: {
-                                            type: "string"
-                                        },
-                                        description: "Why this node matters to an impact trace: `exported`, `test`."
+                                    limit: {
+                                        type: "number",
+                                        description: "Maximum hits to return."
                                     },
-                                    signature: {
+                                    query: {
                                         type: "string",
-                                        description: "The node's signature \u2014 carried on path nodes so the path explains itself."
+                                        description: "What to find, in natural language and code vocabulary mixed freely: 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: [
-                                    "id",
-                                    "name",
-                                    "kind",
-                                    "file"
+                                    "type",
+                                    "query"
                                 ],
                                 additionalProperties: false
-                            }
-                        }
-                    },
-                    parameters: {
-                        type: "object",
-                        properties: {
-                            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 flags the public API and tests a change would reach."
-                            },
-                            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."
-                            },
-                            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."
+                            "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."
+                                    }
+                                },
+                                required: [
+                                    "type"
+                                ],
+                                additionalProperties: false
                             },
-                            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 \u2014\nthe one-call answer for \"how does A reach B\" \u2014 instead of an open-ended\ntrace."
+                            "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 flags the public API and tests a change would reach."
+                                    },
+                                    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."
+                                    },
+                                    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."
+                                    },
+                                    maxDepth: {
+                                        type: "number",
+                                        description: "How many hops deep to follow. Open traces are capped at 2; path mode is\ncapped at 12."
+                                    },
+                                    maxNodes: {
+                                        type: "number",
+                                        description: "Cap on reached nodes; the trace stops and marks itself truncated past it.\nOpen traces are capped at 10 nodes so a broad graph cannot flood\ncontext."
+                                    },
+                                    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."
+                                    }
+                                },
+                                required: [
+                                    "type",
+                                    "from"
+                                ],
+                                additionalProperties: false
                             }
-                        },
-                        required: [
-                            "from"
-                        ],
-                        additionalProperties: false,
-                        $defs: {}
+                        }
                     },
                     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.graphNeed && ("object" === typeof input.draft && null !== input.draft && _io1(input.draft)) && "string" === typeof input.review && ("object" === typeof input.request && null !== input.request && _iu0(input.request));
+                        const _io1 = input => "string" === typeof input.reason && ("details" === input.type || "entrypoints" === input.type || "escape" === input.type || "lookup" === input.type || "overview" === input.type || "trace" === input.type);
+                        const _io2 = 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);
+                        const _io3 = input => "entrypoints" === input.type && "string" === typeof input.query && (undefined === input.limit || "number" === typeof input.limit) && (undefined === input.neighbors || "number" === typeof input.neighbors);
+                        const _io4 = input => "lookup" === input.type && "string" === typeof input.query && (undefined === input.limit || "number" === typeof input.limit);
+                        const _io5 = input => "overview" === input.type && (undefined === input.aspect || "all" === input.aspect || "hotspots" === input.aspect || "layers" === input.aspect || "publicApi" === input.aspect);
+                        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);
+                        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 _io2(input);
+                            else if ("entrypoints" === input.type)
+                                return _io3(input);
+                            else if ("lookup" === input.type)
+                                return _io4(input);
+                            else if ("overview" === 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.graphNeed || _report(_exceptionable, {
+                                path: _path + ".graphNeed",
+                                expected: "string",
+                                value: input.graphNeed
+                            }), ("object" === typeof input.draft && null !== input.draft || _report(_exceptionable, {
+                                path: _path + ".draft",
+                                expected: "ITtscGraphApplication.IRequestDraft",
+                                value: input.draft
+                            })) && _vo1(input.draft, _path + ".draft", true && _exceptionable) || _report(_exceptionable, {
+                                path: _path + ".draft",
+                                expected: "ITtscGraphApplication.IRequestDraft",
+                                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 | 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 | ITtscGraphTrace.IRequest)",
+                                value: input.request
+                            })].every(flag => flag);
+                        const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.reason || _report(_exceptionable, {
+                                path: _path + ".reason",
+                                expected: "string",
+                                value: input.reason
+                            }), "details" === input.type || "entrypoints" === input.type || "escape" === input.type || "lookup" === input.type || "overview" === input.type || "trace" === input.type || _report(_exceptionable, {
+                                path: _path + ".type",
+                                expected: "(\"details\" | \"entrypoints\" | \"escape\" | \"lookup\" | \"overview\" | \"trace\")",
+                                value: input.type
+                            })].every(flag => flag);
+                        const _vo2 = (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
+                            })].every(flag => flag);
+                        const _vo3 = (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 _vo4 = (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
+                            })].every(flag => flag);
+                        const _vo5 = (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 _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 +1589,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)",
@@ -1134,6 +1602,39 @@ function createServer(graph, version) {
                                 expected: "(number | undefined)",
                                 value: input.maxNodes
                             })].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 _vo2(input, _path, true && _exceptionable);
+                            else if ("entrypoints" === input.type)
+                                return _vo3(input, _path, true && _exceptionable);
+                            else if ("lookup" === input.type)
+                                return _vo4(input, _path, true && _exceptionable);
+                            else if ("overview" === 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 | ITtscGraphTrace.IRequest | ITtscGraphEscape.IRequest)",
+                                    value: input
+                                });
+                        })();
                         const __is = input => "object" === typeof input && null !== input && _io0(input);
                         let errors;
                         let _report;
@@ -1143,11 +1644,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 +1694,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 +1707,7 @@ function createServer(graph, version) {
                 content: [
                     {
                         type: "text",
-                        text: result === undefined
-                            ? "Success"
-                            : JSON.stringify(result, null, 2),
+                        text: result === undefined ? "Success" : JSON.stringify(result),
                     },
                 ],
             };