septum 0.1.3 → 0.1.4

package/src/core/topology/types.ts

@@ -0,0 +1,83 @@
+export type EnvironmentLayer =
+  | "edge"
+  | "gateway"
+  | "host"
+  | "runtime"
+  | "storage"
+  | "telemetry";
+
+export type LayerResolutionStatus = "DETECTED" | "AMBIGUOUS" | "UNRESOLVED" | "VERIFIED";
+
+export type CanonicalPlatformTag =
+  | "shared_hosting"
+  | "vps"
+  | "docker"
+  | "serverless"
+  | "kubernetes"
+  | "managed_db"
+  | "cdn_edge"
+  | "paas"
+  | "static_cdn"
+  | "unspecified";
+
+export interface EnvironmentLayerInfo {
+  layer: EnvironmentLayer;
+  platform?: string;
+  canonical_tag?: CanonicalPlatformTag;
+  status: LayerResolutionStatus;
+  detected_from?: string[];
+  evidence?: string[];
+  constraints?: string[];
+  unresolved_inquiry?: string;
+}
+
+export interface TopologyNode {
+  id: string; // e.g. "edge:cloudflare", "host:api-vps", "host:worker-vps", "storage:central-db"
+  layer: EnvironmentLayer;
+  name: string; // e.g. "Cloudflare Perimeter", "API Backend VPS", "Postgres Cluster"
+  platform: string; // e.g. "Cloudflare WAF", "Hostinger VPS", "AWS RDS Postgres"
+  canonical_tag: CanonicalPlatformTag;
+  domain_or_ip?: string; // e.g. "api.example.com", "10.0.0.5"
+  role?: string; // e.g. "web_api", "queue_worker", "frontend_spa", "database_primary"
+  status: LayerResolutionStatus;
+  detected_from: string[];
+  constraints: string[];
+  connected_to?: string[]; // IDs of nodes this node interacts with
+  unresolved_inquiry?: string;
+}
+
+export interface CrossLayerInterplay {
+  title: string;
+  involved_layers: EnvironmentLayer[];
+  involved_node_ids?: string[];
+  risk_or_rule: string;
+  required_action: string;
+}
+
+export interface EnvironmentTopology {
+  is_distributed: boolean;
+  nodes: TopologyNode[];
+  layers: Record<EnvironmentLayer, EnvironmentLayerInfo>;
+  overall_status: "RESOLVED" | "NEEDS_CLARIFICATION";
+  interplays: CrossLayerInterplay[];
+  pending_inquiries: string[];
+  architectural_summary: string;
+}
+
+export interface ResolveLayerInput {
+  layer: EnvironmentLayer;
+  platform: string;
+  constraints?: string[];
+}
+
+export interface ResolveNodeInput {
+  id: string;
+  layer: EnvironmentLayer;
+  name: string;
+  platform: string;
+  canonical_tag?: CanonicalPlatformTag;
+  domain_or_ip?: string;
+  role?: string;
+  constraints?: string[];
+  connected_to?: string[];
+}

package/src/index.ts

@@ -9,6 +9,9 @@ export * from "./core/ingestion/pipeline.ts";
 export * from "./core/boundary/evaluator.ts";
 export * from "./core/resolver/call-graph-tracer.ts";
 export * from "./core/resolver/vertical-slice-tracer.ts";
+export * from "./core/topology/types.ts";
+export * from "./core/topology/environment-detector.ts";
+export * from "./mcp/tools/get-environment-topology.ts";
 export * from "./mcp/server.ts";
 export * from "./cli/index.ts";
 

package/src/mcp/schemas.ts

@@ -189,10 +189,19 @@ export const GetSymbolHotspotsSchema = z.preprocess(
       domain_name: "domain",
       domainName: "domain",
       max: "limit",
+      nesting: "min_nesting",
+      minNesting: "min_nesting",
+      lines: "min_lines",
+      minLines: "min_lines",
+      sortBy: "sort_by",
     }),
   z.object({
+    min_lines: z.number().int().nonnegative().optional(),
+    min_nesting: z.number().int().positive().optional(),
+    kind: z.string().optional(),
     domain: z.string().optional(),
     limit: z.number().int().positive().optional().default(10),
+    sort_by: z.enum(["lines", "nesting", "risk_score"]).optional(),
   })
 );
 export type GetSymbolHotspotsArgs = z.infer<typeof GetSymbolHotspotsSchema>;
@@ -236,3 +245,42 @@ export const AutoDiscoverDomainsSchema = z.preprocess(
 );
 export type AutoDiscoverDomainsArgs = z.infer<typeof AutoDiscoverDomainsSchema>;
 
+export const GetEnvironmentTopologySchema = z.object({
+  resolve: z
+    .object({
+      layer: z.enum(["edge", "gateway", "host", "runtime", "storage", "telemetry"]),
+      platform: z.string().min(1, "platform name cannot be empty"),
+      constraints: z.array(z.string()).optional(),
+    })
+    .optional(),
+  resolveNode: z
+    .object({
+      id: z.string().min(1, "Node id cannot be empty"),
+      layer: z.enum(["edge", "gateway", "host", "runtime", "storage", "telemetry"]),
+      name: z.string().min(1, "Node name cannot be empty"),
+      platform: z.string().min(1, "Platform cannot be empty"),
+      canonical_tag: z
+        .enum([
+          "shared_hosting",
+          "vps",
+          "docker",
+          "serverless",
+          "kubernetes",
+          "managed_db",
+          "cdn_edge",
+          "paas",
+          "static_cdn",
+          "unspecified",
+        ])
+        .optional(),
+      domain_or_ip: z.string().optional(),
+      role: z.string().optional(),
+      constraints: z.array(z.string()).optional(),
+      connected_to: z.array(z.string()).optional(),
+    })
+    .optional(),
+  refresh: z.boolean().optional().default(false),
+});
+export type GetEnvironmentTopologyArgs = z.infer<typeof GetEnvironmentTopologySchema>;
+
+

package/src/mcp/server.ts

@@ -41,10 +41,12 @@ import {
 import { handleGetSymbol } from "./tools/get-symbol.ts";
 import { handleGetSymbolImpact } from "./tools/get-symbol-impact.ts";
 import { handleRegisterDomain } from "./tools/register-domain.ts";
+import { handleGetEnvironmentTopology } from "./tools/get-environment-topology.ts";
 import type { GetSymbolArgs, GetSymbolImpactArgs } from "../types/index.ts";
 import {
   CheckBoundarySchema,
   GetDomainCatalogSchema,
+  GetEnvironmentTopologySchema,
   GetFeatureContextSchema,
   GetSymbolHotspotsSchema,
   GetSymbolImpactSchema,
@@ -180,7 +182,7 @@ export async function runMCPServer(): Promise<void> {
         {
           name: "septum_get_symbol_hotspots",
           description:
-            "Discovers oversized functions, methods, and classes exceeding a specified line count threshold (default: 30 lines). Essential for Single Responsibility Principle (SRP) enforcement, finding God Functions, and isolating refactoring targets deterministically without reading raw files.",
+            "Discovers oversized functions, methods, and classes exceeding a specified line count threshold or cyclomatic control flow nesting depth (> 4). Essential for Single Responsibility Principle (SRP) enforcement, finding God Functions / bug magnets, and isolating refactoring targets deterministically without reading raw files.",
           inputSchema: {
             type: "object",
             properties: {
@@ -188,6 +190,10 @@ export async function runMCPServer(): Promise<void> {
                 type: "number",
                 description: "Minimum physical lines of code (LoC) threshold (default: 30).",
               },
+              min_nesting: {
+                type: "number",
+                description: "Minimum control-flow nesting depth (e.g. nested if/for/while/try > 4).",
+              },
               kind: {
                 type: "string",
                 description: "Filter by symbol kind ('function', 'method', 'class', 'struct', 'interface').",
@@ -200,6 +206,11 @@ export async function runMCPServer(): Promise<void> {
                 type: "number",
                 description: "Maximum results to return (default: 30).",
               },
+              sort_by: {
+                type: "string",
+                enum: ["lines", "nesting", "risk_score"],
+                description: "Sorting criteria: 'risk_score' (combines lines & nesting depth), 'nesting', or 'lines'. Default: 'risk_score'.",
+              },
             },
           },
         },
@@ -329,6 +340,41 @@ export async function runMCPServer(): Promise<void> {
             required: ["name", "root"],
           },
         },
+        {
+          name: "septum_get_environment_topology",
+          description:
+            "Self-Aware Production Topology Engine: Maps and verifies the 6-layer environment topology (Edge/WAF, Gateway/Web Server, Host Platform, Runtime, Storage/Cache, Telemetry). Identifies cross-layer constraints (e.g. Cloudflare + LiteSpeed + Laravel throttle), surfaces pending architectural inquiries if layers are ambiguous, and allows recording verified environment answers to SQLite SSOT.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              resolve: {
+                type: "object",
+                properties: {
+                  layer: {
+                    type: "string",
+                    enum: ["edge", "gateway", "host", "runtime", "storage", "telemetry"],
+                    description: "Target layer to manually resolve/verify",
+                  },
+                  platform: {
+                    type: "string",
+                    description: "Confirmed platform name (e.g. 'Hostinger Shared Hosting', 'Cloudflare WAF', 'LiteSpeed')",
+                  },
+                  constraints: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional list of architectural constraints for this layer",
+                  },
+                },
+                required: ["layer", "platform"],
+                description: "Optional argument to record and verify a specific layer into SQLite SSOT",
+              },
+              refresh: {
+                type: "boolean",
+                description: "Force re-detection from codebase files, ignoring cached status",
+              },
+            },
+          },
+        },
       ],
     };
   });
@@ -483,6 +529,20 @@ export async function runMCPServer(): Promise<void> {
           };
         }
         return await handleRegisterDomain(ctx.repo, ctx.config, parsed.data);
+      } else if (name === "septum_get_environment_topology") {
+        const parsed = GetEnvironmentTopologySchema.safeParse(args ?? {});
+        if (!parsed.success) {
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: `[Septum Validation Error] Invalid arguments for ${name}: ${parsed.error.message}`,
+              },
+            ],
+          };
+        }
+        return handleGetEnvironmentTopology(ctx.repo, ctx.config, parsed.data, ctx.root);
       } else {
         throw new Error(`Unknown tool: '${name}'`);
       }
@@ -510,7 +570,7 @@ export async function runMCPServer(): Promise<void> {
         input: (args as Record<string, any>) ?? {},
         metrics: { bytes_out: bytesOut, lines_out: linesOut },
         session: sessionPayload,
-        status: response?.isError ? "error" : "success",
+        status: (response as { isError?: boolean } | undefined)?.isError ? "error" : "success",
       });
 
       return response;

package/src/mcp/tools/get-environment-topology.ts

@@ -0,0 +1,141 @@
+import type { ValidatedSeptumConfig } from "../../core/config/schema.ts";
+import type { SeptumRepository } from "../../core/database/repository.ts";
+import { EnvironmentDetector } from "../../core/topology/environment-detector.ts";
+import type { EnvironmentLayer, ResolveLayerInput, ResolveNodeInput } from "../../core/topology/types.ts";
+
+export interface GetEnvironmentTopologyArgs {
+  resolve?: ResolveLayerInput;
+  resolveNode?: ResolveNodeInput;
+  refresh?: boolean;
+}
+
+export function handleGetEnvironmentTopology(
+  repo: SeptumRepository,
+  _config: ValidatedSeptumConfig,
+  args: GetEnvironmentTopologyArgs,
+  workspaceRoot: string
+) {
+  // If layer resolution input is provided, persist into SQLite SSOT
+  if (args.resolve) {
+    const existing = repo.environment.getLayer(args.resolve.layer);
+    repo.environment.saveLayer({
+      layer: args.resolve.layer,
+      platform: args.resolve.platform,
+      canonical_tag: EnvironmentDetector.matchCanonicalTag(args.resolve.platform),
+      status: "VERIFIED",
+      constraints: args.resolve.constraints && args.resolve.constraints.length > 0 ? args.resolve.constraints : (existing?.constraints ?? []),
+      detected_from: ["Manual Developer Resolution via Septum"],
+    });
+  }
+
+  // If node resolution input is provided, persist node into SQLite SSOT
+  if (args.resolveNode) {
+    repo.environment.saveNode({
+      id: args.resolveNode.id,
+      layer: args.resolveNode.layer,
+      name: args.resolveNode.name,
+      platform: args.resolveNode.platform,
+      canonical_tag: args.resolveNode.canonical_tag || EnvironmentDetector.matchCanonicalTag(args.resolveNode.platform),
+      domain_or_ip: args.resolveNode.domain_or_ip,
+      role: args.resolveNode.role,
+      status: "VERIFIED",
+      detected_from: ["Manual Developer Resolution via Septum MCP"],
+      constraints: args.resolveNode.constraints ?? [],
+      connected_to: args.resolveNode.connected_to ?? [],
+    });
+  }
+
+  // Detect current topology merging heuristics with SQLite SSOT
+  const topology = EnvironmentDetector.detect(workspaceRoot, repo, args.refresh);
+
+  // Format into high-density Markdown output
+  let output = `### 🌐 Septum Environment & Topology Plane\n\n`;
+  output += `> **Overall Status:** \`${topology.overall_status}\`\n`;
+  output += `> **Topology Mode:** \`${topology.is_distributed ? "DISTRIBUTED MULTI-NODE GRAPH" : "MONOLITHIC SINGLE-NODE"}\`\n`;
+  output += `> **Architecture:** ${topology.architectural_summary}\n\n`;
+
+  // Section 1: Distributed Nodes Graph
+  if (topology.nodes.length > 0) {
+    output += `#### 📦 Distributed Topology Nodes (${topology.nodes.length} entities):\n`;
+    output += `| Node ID | Layer | Platform / Specs | Role | Domain / Host | Connected To | Status |\n`;
+    output += `| :--- | :--- | :--- | :--- | :--- | :--- | :--- |\n`;
+    for (const node of topology.nodes) {
+      const statusBadge = node.status === "VERIFIED" ? "✅ VERIFIED" : node.status === "DETECTED" ? "🔍 DETECTED" : "⚠️ " + node.status;
+      const domain = node.domain_or_ip ? `\`${node.domain_or_ip}\`` : "-";
+      const role = node.role ? `\`${node.role}\`` : "-";
+      const connected = node.connected_to && node.connected_to.length > 0 ? node.connected_to.join(", ") : "-";
+      output += `| **\`${node.id}\`** | ${node.layer.toUpperCase()} | ${node.platform} | ${role} | ${domain} | ${connected} | ${statusBadge} |\n`;
+    }
+    output += `\n`;
+  }
+
+  // Section 2: 6-Layer Summary
+  output += `#### 🗺️ 6-Layer Plane Summary:\n`;
+  output += `| Layer | Plane Domain | Platform / Setup | Status | Evidence / Files |\n`;
+  output += `| :--- | :--- | :--- | :--- | :--- |\n`;
+
+  const layerLabels: Record<EnvironmentLayer, string> = {
+    edge: "Perimeter & WAF",
+    gateway: "Ingress & Web Server",
+    host: "Deployment Platform",
+    runtime: "Application Engine",
+    storage: "Data & Cache",
+    telemetry: "Observability & Logs",
+  };
+
+  for (const layerKey of Object.keys(topology.layers) as EnvironmentLayer[]) {
+    const info = topology.layers[layerKey];
+    const evidence = info.detected_from && info.detected_from.length > 0 ? info.detected_from.join(", ") : "-";
+    const statusBadge = info.status === "VERIFIED" ? "✅ VERIFIED" : info.status === "DETECTED" ? "🔍 DETECTED" : "⚠️ " + info.status;
+    output += `| **${layerKey.toUpperCase()}** | ${layerLabels[layerKey]} | ${info.platform || "Not Defined"} | ${statusBadge} | ${evidence} |\n`;
+  }
+
+  // Section 3: Active Constraints
+  output += `\n#### 📌 Active Architectural Constraints:\n`;
+  let hasConstraints = false;
+  for (const node of topology.nodes) {
+    if (node.constraints && node.constraints.length > 0) {
+      hasConstraints = true;
+      output += `- **\`${node.id}\` (${node.platform}):**\n`;
+      for (const c of node.constraints) {
+        output += `  • ${c}\n`;
+      }
+    }
+  }
+  if (!hasConstraints) {
+    output += `*No specific node constraints recorded.*\n`;
+  }
+
+  // Section 4: Cross-Layer & Distributed Interplays
+  if (topology.interplays.length > 0) {
+    output += `\n#### ⚡ Cross-Layer & Distributed Invariants:\n`;
+    for (const interplay of topology.interplays) {
+      const nodeTrace = interplay.involved_node_ids && interplay.involved_node_ids.length > 0 ? ` (Nodes: \`${interplay.involved_node_ids.join(", ")}\`)` : "";
+      output += `- **${interplay.title}** (Layers: \`${interplay.involved_layers.join(" ➔ ")}\`)${nodeTrace}:\n`;
+      output += `  • *Invarian:* ${interplay.risk_or_rule}\n`;
+      output += `  • *Tindakan Wajib:* ${interplay.required_action}\n`;
+    }
+  }
+
+  // Section 5: Pending Inquiries
+  if (topology.pending_inquiries.length > 0) {
+    output += `\n#### ❓ Pending Architectural Inquiries (Self-Aware Inquiry Required):\n`;
+    output += `Terdapat layer atau node arsitektural yang belum terkonfirmasi. Sebelum mengeksekusi kode terkait deployment/throttling/cron/cookies, klarifikasikan hal berikut ke pengguna:\n`;
+    for (const q of topology.pending_inquiries) {
+      output += `- ${q}\n`;
+    }
+    output += `\n*Untuk mengunci jawaban pengguna ke SQLite SSOT, panggil kembali tool ini dengan argumen:*\n`;
+    output += `\`septum_get_environment_topology(resolve: { layer: "<layer_name>", platform: "<platform_name>" })\`\n`;
+    output += `*atau untuk entitas terdistribusi:*\n`;
+    output += `\`septum_get_environment_topology(resolveNode: { id: "<node_id>", layer: "<layer>", name: "<name>", platform: "<platform>", domain_or_ip: "<domain_or_ip>", role: "<role>" })\`\n`;
+  }
+
+  return {
+    content: [
+      {
+        type: "text" as const,
+        text: output,
+      },
+    ],
+  };
+}

package/src/mcp/tools/get-symbol-hotspots.ts

@@ -4,9 +4,11 @@ import type { SymbolKind } from "../../types/index.ts";
 
 export interface GetSymbolHotspotsArgs {
   min_lines?: number;
-  kind?: SymbolKind;
+  min_nesting?: number;
+  kind?: SymbolKind | string;
   domain?: string;
   limit?: number;
+  sort_by?: "lines" | "nesting" | "risk_score";
 }
 
 export function handleGetSymbolHotspots(
@@ -14,23 +16,31 @@ export function handleGetSymbolHotspots(
   _config: ValidatedSeptumConfig,
   args: GetSymbolHotspotsArgs
 ) {
-  const minLines = args.min_lines ?? 30;
+  const minLines = args.min_lines ?? (args.min_nesting ? 0 : 30);
+  const minNesting = args.min_nesting ?? 1;
   const limit = args.limit ?? 30;
+  const sortBy = args.sort_by ?? "risk_score";
 
   const hotspots = repo.getHotspotSymbols({
     minLines,
-    kind: args.kind,
+    minNesting,
+    kind: args.kind as SymbolKind | undefined,
     domain: args.domain,
     limit,
+    sortBy,
   });
 
   const payload = {
     total_found: hotspots.length,
     threshold_min_lines: minLines,
+    threshold_min_nesting: minNesting,
+    sort_by: sortBy,
     hotspots: hotspots.map((h) => ({
       name: h.name,
       kind: h.kind,
       line_count: h.line_count,
+      nesting_depth: (h as any).nesting_depth ?? 1,
+      risk_score: (h as any).risk_score ?? h.line_count,
       line_span: `${h.line_start}-${h.line_end}`,
       file_path: h.file_path,
       domain: h.domain_name,

package/src/mcp/tools/register-domain.ts

@@ -22,7 +22,7 @@ export async function handleRegisterDomain(
     throw new Error("Missing required arguments: 'name' and 'root' are required.");
   }
 
-  const domainConfig: DomainConfig = {
+  const domainConfig = {
     root: args.root,
     description: args.description || `Domain: ${args.name}`,
     allowed_dependencies: args.allowed_dependencies || [],

package/src/mcp/tools/trace-vertical-slice.ts

@@ -22,72 +22,17 @@ export function handleTraceVerticalSlice(
   const tracer = new VerticalSliceTracer(repo, workspaceRoot);
   const result: VerticalSliceTraceResponse = tracer.trace(args.query);
 
-  let formattedText = "";
+  let formattedText = result.message;
 
-  if (result.found && result.slice) {
-    const s = result.slice;
-    formattedText = `=== VERTICAL SLICE TRACE ===\n`;
-    formattedText += `Query: ${result.query}\n`;
-    formattedText += `Status: RESOLVED\n\n`;
-
-    formattedText += `• Route:\n`;
-    formattedText += `    Method: ${s.route.method}\n`;
-    formattedText += `    URI:    ${s.route.uri}\n`;
-    if (s.route.name) {
-      formattedText += `    Name:   ${s.route.name}\n`;
-    }
-
-    if (s.request) {
-      formattedText += `\n• Request / Validation:\n`;
-      formattedText += `    Class:  ${s.request.class} (${s.request.file || "inline"})\n`;
-      const ruleKeys = Object.keys(s.request.rules);
-      if (ruleKeys.length > 0) {
-        formattedText += `    Rules:\n`;
-        for (const k of ruleKeys) {
-          formattedText += `      - ${k} => ${s.request.rules[k]}\n`;
-        }
-      }
-    }
-
-    formattedText += `\n• Controller Action:\n`;
-    formattedText += `    Class:  ${s.controller.class}@${s.controller.action}\n`;
-    formattedText += `    File:   ${s.controller.file || "unknown"}:${s.controller.line}\n`;
-
-    if (s.model) {
-      formattedText += `\n• Model:\n`;
-      formattedText += `    Class:  ${s.model.class} (${s.model.file || "unknown"})\n`;
-      if (s.model.fillable && s.model.fillable.length > 0) {
-        formattedText += `    Fillable: [${s.model.fillable.join(", ")}]\n`;
-      }
-      if (s.model.casts && Object.keys(s.model.casts).length > 0) {
-        formattedText += `    Casts:    ${JSON.stringify(s.model.casts)}\n`;
-      }
+  if (result.found && result.alternatives && result.alternatives.length > 0) {
+    formattedText += `\n\n• Other Matching Slices:\n`;
+    for (const alt of result.alternatives) {
+      formattedText += `    - ${alt.method} ${alt.uri} -> ${alt.controller}@${alt.action}\n`;
     }
-
-    if (s.frontend) {
-      formattedText += `\n• Frontend Target:\n`;
-      formattedText += `    Page:   ${s.frontend.target}\n`;
-      if (s.frontend.props.length > 0) {
-        formattedText += `    Props:  [${s.frontend.props.join(", ")}]\n`;
-      }
-    }
-
-    if (result.alternatives && result.alternatives.length > 0) {
-      formattedText += `\n• Other Matching Slices:\n`;
-      for (const alt of result.alternatives) {
-        formattedText += `    - ${alt.method} ${alt.uri} -> ${alt.controller}@${alt.action}\n`;
-      }
-    }
-  } else {
-    formattedText = `=== VERTICAL SLICE NOT FOUND ===\n`;
-    formattedText += `Query: ${result.query}\n`;
-    formattedText += `Message: ${result.message}\n`;
-
-    if (result.alternatives && result.alternatives.length > 0) {
-      formattedText += `\nAvailable Slices:\n`;
-      for (const alt of result.alternatives) {
-        formattedText += `    - ${alt.method} ${alt.uri} -> ${alt.controller}@${alt.action}\n`;
-      }
+  } else if (!result.found && result.alternatives && result.alternatives.length > 0) {
+    formattedText += `\n\nAvailable Slices:\n`;
+    for (const alt of result.alternatives) {
+      formattedText += `    - ${alt.method} ${alt.uri} -> ${alt.controller}@${alt.action}\n`;
     }
   }
 

package/src/types/index.ts

@@ -12,6 +12,7 @@ export type ArchetypeKind =
   | "middleware"
   | "request"
   | "resource"
+  | "route"
   | "util"
   | "view"
   | "unknown";
@@ -123,6 +124,7 @@ export interface SymbolRecord {
   line_start: number;
   line_end: number;
   line_count: number;
+  nesting_depth: number;
 }
 
 export interface DependencyRecord {
@@ -142,6 +144,7 @@ export interface ExtractedSymbol {
   line_start: number;
   line_end: number;
   line_count: number;
+  nesting_depth?: number;
 }
 
 export interface ExtractedDependency {
@@ -193,12 +196,17 @@ export interface DomainCatalogResponse {
 export interface ExecutionChainNode {
   stage:
     | "ingress"
+    | "guard"
     | "validation"
     | "controller"
     | "orchestrator"
     | "use_case"
     | "domain"
     | "entity"
+    | "side_effect"
+    | "job"
+    | "event"
+    | "transaction"
     | "egress"
     | "repository"
     | string;
@@ -206,6 +214,14 @@ export interface ExecutionChainNode {
   file?: string;
   line?: number;
   description?: string;
+  table?: string;
+  schema_file?: string;
+  columns_summary?: string;
+  guards?: string[];
+  mutations?: string[];
+  emits?: string[];
+  dispatches?: string[];
+  transactions?: boolean;
 }
 
 export interface VerticalSliceRecord {

package/src/version.ts

@@ -1,3 +1,3 @@
-import packageJson from "../package.json" with { type: "json" };
-
-export const SEPTUM_VERSION: string = packageJson.version;
+import packageJson from "../package.json" with { type: "json" };
+
+export const SEPTUM_VERSION: string = packageJson.version;