diff --git a/src/ZB.MOM.WW.ScadaBridge.ScriptAnalysis/FlowShapePredictor.cs b/src/ZB.MOM.WW.ScadaBridge.ScriptAnalysis/FlowShapePredictor.cs
new file mode 100644
index 00000000..7bd313a5
--- /dev/null
+++ b/src/ZB.MOM.WW.ScadaBridge.ScriptAnalysis/FlowShapePredictor.cs
@@ -0,0 +1,427 @@
+using System.Globalization;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using ZB.MOM.WW.ScadaBridge.Commons.Types.Debugging;
+
+namespace ZB.MOM.WW.ScadaBridge.ScriptAnalysis;
+
+/// <summary>A node of a predicted flow (Flow Debugger design 2026-09-05 §5.5 — the "Predicted" state).</summary>
+/// <param name="Id">Stable id within the flow (<c>n1</c>, <c>n2</c>, …).</param>
+/// <param name="Kind">The step kind this node would produce when run.</param>
+/// <param name="Lane">The swimlane it is drawn in.</param>
+/// <param name="Title">Display title — the route target, script name, attribute name, …</param>
+/// <param name="InputDependent">True when the target is computed from inputs (not a string literal) and could not be predicted statically.</param>
+/// <param name="Note">Advisory text — an early-return guard that precedes this node, a depth cap, a parse error.</param>
+public sealed record PredictedNode(string Id, FlowStepKind Kind, FlowLane Lane, string Title, bool InputDependent, string? Note);
+
+/// <summary>A directed edge between two predicted nodes.</summary>
+/// <param name="From">Source node id.</param>
+/// <param name="To">Target node id.</param>
+/// <param name="CrossesBoundary">True when exactly one end sits in the Central lane (a central↔site hop).</param>
+public sealed record PredictedEdge(string From, string To, bool CrossesBoundary);
+
+/// <summary>The predicted shape of a flow: nodes in source order plus the chain edges between them.</summary>
+public sealed record PredictedFlow(IReadOnlyList<PredictedNode> Nodes, IReadOnlyList<PredictedEdge> Edges)
+{
+    /// <summary>An empty prediction.</summary>
+    public static readonly PredictedFlow Empty = new([], []);
+}
+
+/// <summary>
+/// Predicts the shape of an inbound-API or site-script flow from script <em>syntax</em> alone
+/// (Flow Debugger design 2026-09-05 §5.5): which routed calls, script calls, attribute writes
+/// and attribute waits the script would produce, in source order, before anything runs.
+///
+/// <para>
+/// This is a syntax walk, not a semantic one — it matches the same member-access chains the
+/// script API exposes (<c>Route.To(x).Call(y)</c>, <c>Scripts.Call(y)</c>,
+/// <c>….Attributes.WriteBatchAndWaitAsync(…)</c>, <c>….Attributes[x] = v</c>, …) by text with
+/// whitespace stripped, exactly as <see cref="ScriptTrustValidator"/>'s hardening walker does.
+/// String-literal arguments resolve to titles; anything else is flagged
+/// <see cref="PredictedNode.InputDependent"/>. Branching is not modelled: every recognised call
+/// is emitted once in source order, and an <c>if (…) return …;</c> guard that precedes the next
+/// node is surfaced as a note on that node. The predicted node kinds are exactly the kinds a
+/// traced run records, so the page can overlay the real graph on the prediction by kind + title.
+/// </para>
+///
+/// <para>
+/// Kept DB-free on purpose: a caller supplies <c>resolveRouteScript(instanceCode, scriptName)</c>
+/// to turn a route target into a site script body (Central UI resolves instance → template →
+/// script); this class only decides when to ask.
+/// </para>
+/// </summary>
+public static class FlowShapePredictor
+{
+    /// <summary>Default recursion cap — an inbound method's routed site script is depth 1, a nested <c>Scripts.Call</c> depth 2.</summary>
+    public const int DefaultMaxDepth = 4;
+
+    /// <summary>Note attached to the request node when the script does not parse.</summary>
+    public const string ParseErrorNote = "parse error";
+
+    /// <summary>
+    /// Predicts the flow of an inbound API method: an <see cref="FlowStepKind.InboundRequest"/>
+    /// node first, the method script's calls, one hop into each routed site script the resolver
+    /// can supply (recursively up to <paramref name="maxDepth"/>), and a
+    /// <see cref="FlowStepKind.Response"/> node last.
+    /// </summary>
+    /// <param name="methodName">The inbound method name (titles the request node).</param>
+    /// <param name="methodScript">The method's C# script body.</param>
+    /// <param name="resolveRouteScript">
+    /// <c>(instanceCode, scriptName)</c> → the site script body, or null when it cannot be
+    /// resolved. Called with the literal instance code when the route target is a constant, and
+    /// with the target expression's source text otherwise (so a resolver may still answer for a
+    /// known expression, and a test resolver may answer for anything).
+    /// </param>
+    /// <param name="maxDepth">Recursion cap; nested script bodies beyond it are not expanded.</param>
+    public static PredictedFlow PredictInboundMethod(
+        string methodName,
+        string methodScript,
+        Func<string, string, string?> resolveRouteScript,
+        int maxDepth = DefaultMaxDepth)
+    {
+        ArgumentNullException.ThrowIfNull(resolveRouteScript);
+        var b = new Builder(resolveRouteScript, Math.Max(1, maxDepth));
+        var request = b.AddNode(FlowStepKind.InboundRequest, FlowLane.Central, $"POST /api/{methodName}", inputDependent: false, note: null);
+
+        try
+        {
+            if (!b.Walk(methodScript ?? string.Empty, FlowLane.Central, instanceCode: null, depth: 0))
+                b.Annotate(request, ParseErrorNote);
+        }
+        catch (Exception)
+        {
+            // A predictor must never take the page down; degrade to the request/response pair.
+            b.Reset(keep: 1);
+            b.Annotate(request, ParseErrorNote);
+        }
+
+        b.AddNode(FlowStepKind.Response, FlowLane.Central, "Response", inputDependent: false, note: null);
+        return b.Build();
+    }
+
+    /// <summary>
+    /// Predicts the flow of a site script run: a <see cref="FlowStepKind.ScriptRun"/> node first,
+    /// then the script's attribute writes/waits and nested calls. Nested <c>Scripts.Call</c>
+    /// targets are not expanded (no resolver) — they appear as unexpanded ScriptRun nodes.
+    /// </summary>
+    /// <param name="scriptName">The script name (titles the root node).</param>
+    /// <param name="scriptBody">The script's C# body.</param>
+    /// <param name="maxDepth">Recursion cap.</param>
+    public static PredictedFlow PredictSiteScript(string scriptName, string scriptBody, int maxDepth = DefaultMaxDepth)
+    {
+        var b = new Builder((_, _) => null, Math.Max(1, maxDepth));
+        var root = b.AddNode(FlowStepKind.ScriptRun, FlowLane.Site, scriptName, inputDependent: false, note: null);
+
+        try
+        {
+            if (!b.Walk(scriptBody ?? string.Empty, FlowLane.Site, instanceCode: null, depth: 1))
+                b.Annotate(root, ParseErrorNote);
+        }
+        catch (Exception)
+        {
+            b.Reset(keep: 1);
+            b.Annotate(root, ParseErrorNote);
+        }
+
+        return b.Build();
+    }
+
+    /// <summary>Accumulates nodes/edges and owns the chain ("previous node") state across nested walks.</summary>
+    private sealed class Builder
+    {
+        private readonly Func<string, string, string?> _resolve;
+        private readonly int _maxDepth;
+        private readonly List<PredictedNode> _nodes = [];
+        private readonly List<PredictedEdge> _edges = [];
+        private string? _previous;
+        private string? _pendingNote;
+
+        internal Builder(Func<string, string, string?> resolve, int maxDepth)
+        {
+            _resolve = resolve;
+            _maxDepth = maxDepth;
+        }
+
+        internal PredictedFlow Build() => new(_nodes.ToArray(), _edges.ToArray());
+
+        /// <summary>Adds a node, chains it to the previous one, and consumes any pending early-return note.</summary>
+        internal string AddNode(FlowStepKind kind, FlowLane lane, string title, bool inputDependent, string? note)
+        {
+            var id = "n" + (_nodes.Count + 1).ToString(CultureInfo.InvariantCulture);
+            var mergedNote = note ?? _pendingNote;
+            if (note != null && _pendingNote != null)
+                mergedNote = $"{_pendingNote}; {note}";
+            _pendingNote = null;
+
+            _nodes.Add(new PredictedNode(id, kind, lane, title, inputDependent, mergedNote));
+            if (_previous != null)
+            {
+                var fromLane = _nodes.First(n => n.Id == _previous).Lane;
+                _edges.Add(new PredictedEdge(_previous, id, (fromLane == FlowLane.Central) != (lane == FlowLane.Central)));
+            }
+
+            _previous = id;
+            return id;
+        }
+
+        internal void Annotate(string id, string note)
+        {
+            var i = _nodes.FindIndex(n => n.Id == id);
+            if (i < 0) return;
+            var n = _nodes[i];
+            _nodes[i] = n with { Note = n.Note == null ? note : $"{n.Note}; {note}" };
+        }
+
+        /// <summary>Drops everything after the first <paramref name="keep"/> nodes (fault recovery).</summary>
+        internal void Reset(int keep)
+        {
+            if (_nodes.Count > keep) _nodes.RemoveRange(keep, _nodes.Count - keep);
+            var ids = _nodes.Select(n => n.Id).ToHashSet(StringComparer.Ordinal);
+            _edges.RemoveAll(e => !ids.Contains(e.From) || !ids.Contains(e.To));
+            _previous = _nodes.Count > 0 ? _nodes[^1].Id : null;
+            _pendingNote = null;
+        }
+
+        /// <summary>
+        /// Walks one script body in the given lane. Returns false when the body has parse
+        /// errors (nothing is emitted for it), true otherwise.
+        /// </summary>
+        internal bool Walk(string code, FlowLane lane, string? instanceCode, int depth)
+        {
+            var tree = CSharpSyntaxTree.ParseText(code, new CSharpParseOptions(kind: SourceCodeKind.Script));
+            if (tree.GetDiagnostics().Any(d => d.Severity == DiagnosticSeverity.Error))
+                return false;
+
+            new Walker(this, lane, instanceCode, depth).Visit(tree.GetRoot());
+            _pendingNote = null; // a trailing guard with nothing after it has no node to annotate
+            return true;
+        }
+
+        internal void QueueNote(string note)
+            => _pendingNote = _pendingNote == null ? note : $"{_pendingNote}; {note}";
+
+        /// <summary>Expands a routed / nested script call one level, if the resolver can supply its body.</summary>
+        internal void ExpandScript(string instanceCode, string scriptName, int depth)
+        {
+            if (depth >= _maxDepth)
+            {
+                Annotate(_previous!, "depth limit reached; not expanded");
+                return;
+            }
+
+            string? body;
+            try
+            {
+                body = _resolve(instanceCode, scriptName);
+            }
+            catch (Exception)
+            {
+                body = null;
+            }
+
+            if (body == null)
+                return;
+
+            if (!Walk(body, FlowLane.Site, instanceCode, depth + 1))
+                Annotate(_previous!, ParseErrorNote);
+        }
+    }
+
+    /// <summary>Source-order visitor that turns recognised script-API calls into nodes.</summary>
+    private sealed class Walker : CSharpSyntaxWalker
+    {
+        private readonly Builder _b;
+        private readonly FlowLane _lane;
+        private readonly string? _instanceCode;
+        private readonly int _depth;
+
+        internal Walker(Builder b, FlowLane lane, string? instanceCode, int depth)
+        {
+            _b = b;
+            _lane = lane;
+            _instanceCode = instanceCode;
+            _depth = depth;
+        }
+
+        private static string Strip(string text) => new(text.Where(c => !char.IsWhiteSpace(c)).ToArray());
+
+        /// <summary>
+        /// An <c>if (…) { … return …; }</c> guard becomes a note on the node that FOLLOWS it.
+        /// The condition is visited first (it may itself contain a traced call — the Delmia
+        /// site script's <c>if (!await …WriteBatchAndWaitAsync(…)) return …</c>), then the
+        /// body, and only then is the note queued for whatever comes next.
+        /// </summary>
+        public override void VisitIfStatement(IfStatementSyntax node)
+        {
+            Visit(node.Condition);
+            Visit(node.Statement);
+            if (node.Else != null)
+                Visit(node.Else);
+
+            var returnsEarly = node.Statement.DescendantNodesAndSelf().OfType<ReturnStatementSyntax>().Any()
+                || node.Statement.DescendantNodesAndSelf().OfType<ThrowStatementSyntax>().Any();
+            if (returnsEarly)
+                _b.QueueNote($"early return: {Condense(node.Condition.ToString())}");
+        }
+
+        public override void VisitAssignmentExpression(AssignmentExpressionSyntax node)
+        {
+            // recv.Attributes["X"] = v  /  Attributes["X"] = v
+            if (node.Left is ElementAccessExpressionSyntax ea
+                && Strip(ea.Expression.ToString()) is var recv
+                && (recv == "Attributes" || recv.EndsWith(".Attributes", StringComparison.Ordinal)))
+            {
+                var (attr, dependent) = LiteralOrExpr(ea.ArgumentList.Arguments.FirstOrDefault()?.Expression);
+                _b.AddNode(FlowStepKind.AttributeWrite, FlowLane.Tags, Qualify(attr), dependent, null);
+            }
+
+            base.VisitAssignmentExpression(node);
+        }
+
+        public override void VisitInvocationExpression(InvocationExpressionSyntax node)
+        {
+            // Visit inner invocations first? No — source order for a chained call like
+            // Route.To(x).Call(y) is the outer call; the inner To(x) is part of its target.
+            // Nested invocations inside ARGUMENTS are visited after this node is emitted,
+            // which is the order they would produce trace rows only when they are awaited
+            // first — acceptable for a shape preview.
+            var handled = TryHandle(node);
+            if (!handled)
+                base.VisitInvocationExpression(node);
+            else
+                foreach (var arg in node.ArgumentList.Arguments)
+                    Visit(arg.Expression);
+        }
+
+        private bool TryHandle(InvocationExpressionSyntax node)
+        {
+            if (node.Expression is not MemberAccessExpressionSyntax ma)
+                return false;
+
+            var member = ma.Name.Identifier.ValueText;
+            var receiverText = Strip(ma.Expression.ToString());
+            var args = node.ArgumentList.Arguments;
+
+            // Route.To(<target>).Call(<script>, …) / .SetAttributes(…) / .WaitForAttribute(…)
+            if (ma.Expression is InvocationExpressionSyntax inner
+                && inner.Expression is MemberAccessExpressionSyntax innerMa
+                && Strip(innerMa.ToString()) == "Route.To")
+            {
+                var (target, targetDependent) = LiteralOrExpr(inner.ArgumentList.Arguments.FirstOrDefault()?.Expression);
+                switch (member)
+                {
+                    case "Call":
+                    {
+                        var (script, scriptDependent) = LiteralOrExpr(args.FirstOrDefault()?.Expression);
+                        var title = targetDependent ? $"Route.To({target}).Call({script})" : $"{target}.{script}";
+                        _b.AddNode(FlowStepKind.RouteCall, FlowLane.Central, title, targetDependent || scriptDependent,
+                            targetDependent ? "route target is computed from inputs" : null);
+                        if (!scriptDependent)
+                        {
+                            var runTitle = targetDependent ? script : $"{target}.{script}";
+                            _b.AddNode(FlowStepKind.ScriptRun, FlowLane.Site, runTitle, targetDependent, null);
+                            _b.ExpandScript(target, script, _depth);
+                        }
+                        return true;
+                    }
+                    case "SetAttributes":
+                        _b.AddNode(FlowStepKind.AttributeWrite, FlowLane.Tags, $"{target}.SetAttributes", true, null);
+                        return true;
+                    case "WaitForAttribute":
+                    {
+                        var (attr, dependent) = LiteralOrExpr(args.FirstOrDefault()?.Expression);
+                        _b.AddNode(FlowStepKind.AttributeWait, FlowLane.Site, $"{target}.{attr}", targetDependent || dependent, null);
+                        return true;
+                    }
+                    default:
+                        return false; // GetAttributes and friends are reads — no trace row, no node
+                }
+            }
+
+            // Scripts.Call("Name", …) — a nested script run on the same instance.
+            if (receiverText == "Scripts" && member == "Call")
+            {
+                var (script, dependent) = LiteralOrExpr(args.FirstOrDefault()?.Expression);
+                _b.AddNode(FlowStepKind.ScriptRun, FlowLane.Site, Qualify(script), dependent, null);
+                if (!dependent && _instanceCode != null)
+                    _b.ExpandScript(_instanceCode, script, _depth);
+                return true;
+            }
+
+            // ….Attributes.<op>(…)
+            if (receiverText == "Attributes" || receiverText.EndsWith(".Attributes", StringComparison.Ordinal))
+            {
+                switch (member)
+                {
+                    case "WriteBatchAndWaitAsync":
+                    {
+                        // (batch, triggerAttr, triggerValue, waitAttr, waitValue, timeout)
+                        var (trigger, triggerDependent) = LiteralOrExpr(args.ElementAtOrDefault(1)?.Expression);
+                        var (wait, waitDependent) = LiteralOrExpr(args.ElementAtOrDefault(3)?.Expression);
+                        _b.AddNode(FlowStepKind.AttributeWrite, FlowLane.Tags, Qualify($"batch + {trigger}"), triggerDependent, null);
+                        _b.AddNode(FlowStepKind.AttributeWait, FlowLane.Site, Qualify(wait), waitDependent, null);
+                        return true;
+                    }
+                    case "WaitAsync":
+                    case "WaitForAsync":
+                    {
+                        var (attr, dependent) = LiteralOrExpr(args.FirstOrDefault()?.Expression);
+                        _b.AddNode(FlowStepKind.AttributeWait, FlowLane.Site, Qualify(attr), dependent, null);
+                        return true;
+                    }
+                    case "SetAsync":
+                    {
+                        var (attr, dependent) = LiteralOrExpr(args.FirstOrDefault()?.Expression);
+                        _b.AddNode(FlowStepKind.AttributeWrite, FlowLane.Tags, Qualify(attr), dependent, null);
+                        return true;
+                    }
+                    default:
+                        return false;
+                }
+            }
+
+            // ExternalSystem.Call / CachedCall, Database.*, Notify.Send — shown, never chained across.
+            if (receiverText == "ExternalSystem" && member is "Call" or "CachedCall")
+            {
+                var (system, dependent) = LiteralOrExpr(args.FirstOrDefault()?.Expression);
+                _b.AddNode(FlowStepKind.External, _lane, $"ExternalSystem.{member}({system})", dependent, null);
+                return true;
+            }
+
+            if (receiverText == "Database")
+            {
+                var (conn, dependent) = LiteralOrExpr(args.FirstOrDefault()?.Expression);
+                _b.AddNode(FlowStepKind.External, _lane, $"Database.{member}({conn})", dependent, null);
+                return true;
+            }
+
+            if (receiverText == "Notify" && member == "Send")
+            {
+                _b.AddNode(FlowStepKind.External, _lane, "Notify.Send", false, null);
+                return true;
+            }
+
+            return false;
+        }
+
+        private string Qualify(string name)
+            => _instanceCode == null ? name : $"{_instanceCode}.{name}";
+
+        /// <summary>A string literal resolves to its value; anything else is input-dependent and shown as its source text.</summary>
+        private static (string Text, bool Dependent) LiteralOrExpr(ExpressionSyntax? expr)
+        {
+            if (expr == null)
+                return ("?", true);
+            if (expr is LiteralExpressionSyntax lit && lit.IsKind(SyntaxKind.StringLiteralExpression))
+                return (lit.Token.ValueText, false);
+            return (Condense(expr.ToString()), true);
+        }
+
+        private static string Condense(string text)
+        {
+            var oneLine = string.Join(" ", text.Split(['\r', '\n'], StringSplitOptions.RemoveEmptyEntries).Select(l => l.Trim()));
+            return oneLine.Length <= 80 ? oneLine : oneLine[..77] + "…";
+        }
+    }
+}
diff --git a/tests/ZB.MOM.WW.ScadaBridge.ScriptAnalysis.Tests/FlowShapePredictorTests.cs b/tests/ZB.MOM.WW.ScadaBridge.ScriptAnalysis.Tests/FlowShapePredictorTests.cs
new file mode 100644
index 00000000..084b6ef4
--- /dev/null
+++ b/tests/ZB.MOM.WW.ScadaBridge.ScriptAnalysis.Tests/FlowShapePredictorTests.cs
@@ -0,0 +1,218 @@
+using ZB.MOM.WW.ScadaBridge.Commons.Types.Debugging;
+using ZB.MOM.WW.ScadaBridge.ScriptAnalysis;
+
+namespace ZB.MOM.WW.ScadaBridge.ScriptAnalysis.Tests;
+
+/// <summary>
+/// Tests for <see cref="FlowShapePredictor"/> (Flow Debugger design 2026-09-05 §5.5) against
+/// the Delmia recipe-download scripts verbatim from
+/// <c>docs/api-specs/Delmia-Recipe-Download-API.md</c> §4.
+/// </summary>
+public class FlowShapePredictorTests
+{
+    private const string DelmiaMethodScript = """
+        try {
+          System.Func<string, object> P = k => Parameters.ContainsKey(k) ? Parameters[k] : null;
+          var code = (P("MachineCode") as string ?? "").Trim();
+          if (string.IsNullOrEmpty(code)) return new { Result = false, ResultText = "MachineCode is required" };
+          var suf = code.Substring(code.Length - 1);
+
+          return await Route.To(code).Call("ProcessRecipeDownload", new {
+              DownloadPath    = P("DownloadPath"),
+              WorkOrderNumber = P("WorkOrderNumber"),
+              PartNumber      = P("PartNumber"),
+              JobStepNumber   = P("JobStepNumber"),
+              Username        = P("Username"),
+          });
+        } catch (Exception ex) {
+          return new { Result = false, ResultText = "RecipeDownload failed: " + ex.Message };
+        }
+        """;
+
+    private const string DelmiaSiteScript = """
+        // Generic DELMIA recipe-download — performed DIRECTLY on the composed DelmiaReceiver child
+        var recv = Children["DelmiaRecv"];
+        System.Func<object,bool> IsTrue = v => { var s=v?.ToString(); return (v is bool b && b)||s=="1"||string.Equals(s,"true",System.StringComparison.OrdinalIgnoreCase); };
+        System.Func<string,object?> P = k => Parameters.ContainsKey(k) ? Parameters[k] : null;
+        if (!IsTrue(recv.Attributes["ReadyFlag"]))
+            return new { Result=false, ResultText="Receiver ready flag not set to true" };
+        try {
+            recv.Attributes["RecipeProcessedFlag"] = false;
+            var data = new System.Collections.Generic.Dictionary<string, object?> {
+                { "DownloadPath", P("DownloadPath") },
+                { "WorkOrderNumber", P("WorkOrderNumber") },
+                { "PartNumber", P("PartNumber") },
+                { "JobStepNumber", P("JobStepNumber") },
+                { "Username", P("Username") },
+            };
+            if (!await recv.Attributes.WriteBatchAndWaitAsync(data, "RecipeDownloadFlag", true, "RecipeProcessedFlag", true, System.TimeSpan.FromSeconds(25)))
+                return new { Result=false, ResultText="Timeout waiting for recipe to be processed" };
+            return new {
+                Result = IsTrue(recv.Attributes["RecipeProcessResult"]),
+                ResultText = recv.Attributes["RecipeProcessResultText"]?.ToString() ?? ""
+            };
+        } catch (Exception ex) {
+            return new { Result=false, ResultText="RecipeDownload failed: " + ex.Message };
+        }
+        """;
+
+    private static string? AnySiteScript(string instanceCode, string scriptName)
+        => scriptName == "ProcessRecipeDownload" ? DelmiaSiteScript : null;
+
+    [Fact]
+    public void Delmia_MethodPlusSiteScript_PredictsTheFullSwimlaneShape()
+    {
+        var flow = FlowShapePredictor.PredictInboundMethod("DelmiaRecipeDownload", DelmiaMethodScript, AnySiteScript);
+
+        // Request → route call → site run → RecipeProcessedFlag write → batch write → wait → response.
+        // (The InboundRequest node IS the method-script run: the real graph records no separate
+        // "method script" step, so the prediction mirrors that to keep the overlay honest.)
+        var kinds = flow.Nodes.Select(n => (n.Kind, n.Lane)).ToList();
+        Assert.Equal(
+        [
+            (FlowStepKind.InboundRequest, FlowLane.Central),
+            (FlowStepKind.RouteCall, FlowLane.Central),
+            (FlowStepKind.ScriptRun, FlowLane.Site),
+            (FlowStepKind.AttributeWrite, FlowLane.Tags),
+            (FlowStepKind.AttributeWrite, FlowLane.Tags),
+            (FlowStepKind.AttributeWait, FlowLane.Site),
+            (FlowStepKind.Response, FlowLane.Central),
+        ], kinds);
+
+        Assert.Equal("POST /api/DelmiaRecipeDownload", flow.Nodes[0].Title);
+
+        // The route target is `code`, computed from Parameters — input-dependent.
+        var route = flow.Nodes[1];
+        Assert.True(route.InputDependent);
+        Assert.Contains("Route.To(code)", route.Title);
+        Assert.Contains("ProcessRecipeDownload", route.Title);
+        // The early-return guard that precedes the route call is surfaced on it.
+        Assert.Contains("early return: string.IsNullOrEmpty(code)", route.Note);
+
+        Assert.Equal("ProcessRecipeDownload", flow.Nodes[2].Title);
+        Assert.Contains("RecipeProcessedFlag", flow.Nodes[3].Title);
+        Assert.Contains("early return: !IsTrue(recv.Attributes[\"ReadyFlag\"])", flow.Nodes[3].Note);
+        Assert.Contains("RecipeDownloadFlag", flow.Nodes[4].Title);
+        Assert.Contains("RecipeProcessedFlag", flow.Nodes[5].Title);
+        Assert.False(flow.Nodes[5].InputDependent);
+
+        // Chain edges: n1→n2 (central), n2→n3 crosses, n3→n4, n4→n5, n5→n6, n6→n7 crosses back.
+        Assert.Equal(6, flow.Edges.Count);
+        Assert.All(flow.Edges.Zip(flow.Nodes.Skip(1)), pair => Assert.Equal(pair.Second.Id, pair.First.To));
+        Assert.True(flow.Edges[1].CrossesBoundary);
+        Assert.False(flow.Edges[2].CrossesBoundary);
+        Assert.True(flow.Edges[^1].CrossesBoundary);
+    }
+
+    [Fact]
+    public void ConstantRouteTarget_IsNotInputDependent_AndQualifiesSiteTitles()
+    {
+        const string script = """
+            return await Route.To("Z28061Sim").Call("ProcessRecipeDownload", new { A = 1 });
+            """;
+
+        var flow = FlowShapePredictor.PredictInboundMethod("M", script, AnySiteScript);
+
+        var route = flow.Nodes.Single(n => n.Kind == FlowStepKind.RouteCall);
+        Assert.False(route.InputDependent);
+        Assert.Equal("Z28061Sim.ProcessRecipeDownload", route.Title);
+        Assert.Null(route.Note);
+
+        var run = flow.Nodes.Single(n => n.Kind == FlowStepKind.ScriptRun);
+        Assert.Equal("Z28061Sim.ProcessRecipeDownload", run.Title);
+        var write = flow.Nodes.First(n => n.Kind == FlowStepKind.AttributeWrite);
+        Assert.StartsWith("Z28061Sim.", write.Title);
+    }
+
+    [Fact]
+    public void ResolverReturningNull_LeavesTheSiteRunUnexpanded()
+    {
+        const string script = """return await Route.To("X").Call("S");""";
+
+        var flow = FlowShapePredictor.PredictInboundMethod("M", script, (_, _) => null);
+
+        Assert.Equal(
+        [
+            FlowStepKind.InboundRequest, FlowStepKind.RouteCall, FlowStepKind.ScriptRun, FlowStepKind.Response,
+        ], flow.Nodes.Select(n => n.Kind).ToList());
+    }
+
+    [Fact]
+    public void NoRecognisedCall_YieldsOnlyRequestAndResponse()
+    {
+        var flow = FlowShapePredictor.PredictInboundMethod("Ping", "return new { Ok = true };", AnySiteScript);
+
+        Assert.Equal(2, flow.Nodes.Count);
+        Assert.Equal(FlowStepKind.InboundRequest, flow.Nodes[0].Kind);
+        Assert.Equal(FlowStepKind.Response, flow.Nodes[1].Kind);
+        Assert.Null(flow.Nodes[0].Note);
+        var edge = Assert.Single(flow.Edges);
+        Assert.False(edge.CrossesBoundary);
+    }
+
+    [Fact]
+    public void Recursion_StopsAtMaxDepth()
+    {
+        // Each site script calls the next one; the resolver always answers.
+        static string? Chain(string _, string name) => $"""await Scripts.Call("{name}x");""";
+        const string method = """return await Route.To("I").Call("A");""";
+
+        var shallow = FlowShapePredictor.PredictInboundMethod("M", method, Chain, maxDepth: 2);
+        var deep = FlowShapePredictor.PredictInboundMethod("M", method, Chain, maxDepth: 4);
+
+        // maxDepth 2: A's body is walked at depth 1 (adds Ax), Ax's at depth 2 (adds Axx),
+        // Axx is not expanded → 3 runs. maxDepth 4 → A, Ax, Axx, Axxx, Axxxx = 5.
+        Assert.Equal(3, shallow.Nodes.Count(n => n.Kind == FlowStepKind.ScriptRun));
+        Assert.Equal(5, deep.Nodes.Count(n => n.Kind == FlowStepKind.ScriptRun));
+        Assert.Contains(shallow.Nodes, n => n.Note?.Contains("depth limit") == true);
+        Assert.True(deep.Nodes.Count > shallow.Nodes.Count);
+    }
+
+    [Fact]
+    public void MalformedCode_NeverThrows_AndNotesTheParseError()
+    {
+        var flow = FlowShapePredictor.PredictInboundMethod("M", "return await Route.To(\"X\").Call(", AnySiteScript);
+
+        Assert.Equal(2, flow.Nodes.Count);
+        Assert.Equal(FlowShapePredictor.ParseErrorNote, flow.Nodes[0].Note);
+        Assert.Equal(FlowStepKind.Response, flow.Nodes[1].Kind);
+
+        var site = FlowShapePredictor.PredictSiteScript("S", "if (");
+        var root = Assert.Single(site.Nodes);
+        Assert.Equal(FlowShapePredictor.ParseErrorNote, root.Note);
+    }
+
+    [Fact]
+    public void PredictSiteScript_RootsAtTheScriptRun_AndRecognisesAttributeOps()
+    {
+        const string body = """
+            await Attributes.SetAsync("Cmd", 1);
+            await Attributes.WaitAsync("Ack", true, System.TimeSpan.FromSeconds(5));
+            var r = await ExternalSystem.Call("Mes", "Post", new { });
+            await Notify.Send("ops", "done");
+            """;
+
+        var flow = FlowShapePredictor.PredictSiteScript("Handshake", body);
+
+        Assert.Equal(
+        [
+            (FlowStepKind.ScriptRun, "Handshake"),
+            (FlowStepKind.AttributeWrite, "Cmd"),
+            (FlowStepKind.AttributeWait, "Ack"),
+            (FlowStepKind.External, "ExternalSystem.Call(Mes)"),
+            (FlowStepKind.External, "Notify.Send"),
+        ], flow.Nodes.Select(n => (n.Kind, n.Title)).ToList());
+        Assert.DoesNotContain(flow.Nodes, n => n.Lane == FlowLane.Central);
+        Assert.All(flow.Edges, e => Assert.False(e.CrossesBoundary));
+    }
+
+    [Fact]
+    public void InputDependentAttributeName_IsFlagged()
+    {
+        var flow = FlowShapePredictor.PredictSiteScript("S", """Attributes[name] = 1;""");
+
+        var write = flow.Nodes.Single(n => n.Kind == FlowStepKind.AttributeWrite);
+        Assert.True(write.InputDependent);
+        Assert.Equal("name", write.Title);
+    }
+}