Complete Entrypoint Detection Re-Engineering Program (Sprints 0410-0415) and Sprint 3500.0002.0003 (Proof Replay + API)

Entrypoint Detection Program (100% complete):
- Sprint 0411: Semantic Entrypoint Engine - all 25 tasks DONE
- Sprint 0412: Temporal & Mesh Entrypoint - all 19 tasks DONE
- Sprint 0413: Speculative Execution Engine - all 19 tasks DONE
- Sprint 0414: Binary Intelligence - all 19 tasks DONE
- Sprint 0415: Predictive Risk Scoring - all tasks DONE

Key deliverables:
- SemanticEntrypoint schema with ApplicationIntent/CapabilityClass
- TemporalEntrypointGraph and MeshEntrypointGraph
- ShellSymbolicExecutor with PathEnumerator and PathConfidenceScorer
- CodeFingerprint index with symbol recovery
- RiskScore with multi-dimensional risk assessment

Sprint 3500.0002.0003 (Proof Replay + API):
- ManifestEndpoints with DSSE content negotiation
- Proof bundle endpoints by root hash
- IdempotencyMiddleware with RFC 9530 Content-Digest
- Rate limiting (100 req/hr per tenant)
- OpenAPI documentation updates

Tests: 357 EntryTrace tests pass, WebService tests blocked by pre-existing infrastructure issue

src/Scanner/__Libraries/StellaOps.Scanner.EntryTrace/Speculative/ISymbolicExecutor.cs

@@ -46,13 +46,15 @@ public interface ISymbolicExecutor
 /// <param name="ConstraintEvaluator">Evaluator for path feasibility.</param>
 /// <param name="TrackAllCommands">Whether to track all commands or just terminal ones.</param>
 /// <param name="PruneInfeasiblePaths">Whether to prune paths with unsatisfiable constraints.</param>
+/// <param name="ScriptPath">Path to the script being analyzed (for reporting).</param>
 public sealed record SymbolicExecutionOptions(
     int MaxDepth = 100,
     int MaxPaths = 1000,
     IReadOnlyDictionary<string, string>? InitialEnvironment = null,
     IConstraintEvaluator? ConstraintEvaluator = null,
     bool TrackAllCommands = false,
-    bool PruneInfeasiblePaths = true)
+    bool PruneInfeasiblePaths = true,
+    string? ScriptPath = null)
 {
     /// <summary>
     /// Default options with reasonable limits.

src/Scanner/__Libraries/StellaOps.Scanner.EntryTrace/Speculative/PathConfidenceScorer.cs

@@ -43,6 +43,20 @@ public sealed class PathConfidenceScorer
     {
         weights ??= DefaultWeights;
         
+        // Short-circuit: Infeasible paths have near-zero confidence
+        if (!path.IsFeasible)
+        {
+            return new PathConfidenceAnalysis(
+                path.PathId,
+                0.05f, // Near-zero confidence for infeasible paths
+                ImmutableArray.Create(new ConfidenceFactor(
+                    "Feasibility",
+                    0.0f,
+                    1.0f,
+                    "path is infeasible")),
+                ConfidenceLevel.Low);
+        }
+        
         var factors = new List<ConfidenceFactor>();
         
         // Factor 1: Constraint complexity

src/Scanner/__Libraries/StellaOps.Scanner.EntryTrace/Speculative/ShellSymbolicExecutor.cs

@@ -47,7 +47,10 @@ public sealed class ShellSymbolicExecutor : ISymbolicExecutor
         CancellationToken cancellationToken = default)
     {
         var script = ShellParser.Parse(source);
-        return ExecuteAsync(script, options ?? SymbolicExecutionOptions.Default, cancellationToken);
+        var opts = options ?? SymbolicExecutionOptions.Default;
+        // Ensure the scriptPath is carried through to the execution tree
+        var optionsWithPath = opts with { ScriptPath = scriptPath };
+        return ExecuteAsync(script, optionsWithPath, cancellationToken);
     }
     
     /// <inheritdoc/>
@@ -56,7 +59,8 @@ public sealed class ShellSymbolicExecutor : ISymbolicExecutor
         SymbolicExecutionOptions options,
         CancellationToken cancellationToken = default)
     {
-        var builder = new ExecutionTreeBuilder("script", options.MaxDepth);
+        var scriptPath = options.ScriptPath ?? "script";
+        var builder = new ExecutionTreeBuilder(scriptPath, options.MaxDepth);
         var constraintEvaluator = options.ConstraintEvaluator ?? PatternConstraintEvaluator.Instance;
         
         var initialState = options.InitialEnvironment is { } env