pi-revit 0.3.1 → 0.5.0

package/src/Revit/Tools/GetSchedules.cs

@@ -0,0 +1,96 @@
+using System.Text.Json;
+using Autodesk.Revit.DB;
+
+namespace RevitBridge.Tools;
+
+internal sealed class GetSchedules : ITool
+{
+    public string Name => "get_schedules";
+    public IReadOnlyList<string> DocumentKinds => DocumentKind.ProjectOnly;
+    public IReadOnlyList<string> Keywords => new[] { "schedule", "quantities", "takeoff", "table", "schedule cells", "schedule values", "bill of quantities" };
+    public IReadOnlyList<ToolLimit> Limits => new[]
+    {
+        new ToolLimit("Titleblock revision schedules and schedule templates", "api", "ViewSchedule.IsTitleblockRevisionSchedule; ViewSchedule.GetTableData"),
+        new ToolLimit("Graphical layout of a schedule on a sheet", "tool", "capture_view"),
+    };
+    public string Label => "Get Schedules";
+    public string Tier => "advanced";
+    public string Description => "List schedules, or read one schedule's field definitions and displayed body cells by schedule_id. Cell text uses Revit formatting and may contain group headings/totals; rows are not guaranteed to correspond to individual elements. Row and column pagination are independent. Templates and revision schedules are excluded from the list.";
+    public object ParametersSchema => new
+    {
+        type = "object",
+        properties = new
+        {
+            schedule_id = new { type = "integer" },
+            name_filter = new { type = "string" },
+            offset = new { type = "integer", minimum = 0, description = "List offset or body row offset." },
+            limit = new { type = "integer", minimum = 1, maximum = 200 },
+            column_offset = new { type = "integer", minimum = 0 },
+            column_limit = new { type = "integer", minimum = 1, maximum = 50 },
+        },
+        required = Array.Empty<string>(),
+    };
+
+    public object Execute(JsonElement args, ToolContext context)
+    {
+        var doc = context.Document ?? throw new NoActiveDocumentException();
+        int offset = Math.Max(0, JsonArgs.GetInt(args, "offset", 0));
+        int limit = Math.Clamp(JsonArgs.GetInt(args, "limit", 50), 1, 200);
+        if (JsonArgs.GetLong(args, "schedule_id") is not { } id)
+        {
+            string needle = JsonArgs.GetString(args, "name_filter") ?? "";
+            var schedules = new FilteredElementCollector(doc).OfClass(typeof(ViewSchedule)).Cast<ViewSchedule>()
+                .Where(s => !s.IsTemplate && !s.IsTitleblockRevisionSchedule && s.Name.Contains(needle, StringComparison.OrdinalIgnoreCase))
+                .OrderBy(s => s.Id.Value).ToList();
+            var rows = schedules.Skip(offset).Take(limit).Select(s => new
+            {
+                id = s.Id.Value, name = s.Name, unique_id = s.UniqueId,
+                category_id = s.Definition.CategoryId.Value,
+                is_itemized = s.Definition.IsItemized,
+                field_count = s.Definition.GetFieldCount(),
+            }).ToArray();
+            return new { total_count = schedules.Count, returned_count = rows.Length, offset,
+                has_more = offset + rows.Length < schedules.Count,
+                next_offset = offset + rows.Length < schedules.Count ? (int?)(offset + rows.Length) : null, schedules = rows };
+        }
+
+        var schedule = doc.GetElement(new ElementId(id)) as ViewSchedule
+            ?? throw new ArgumentException("schedule_id is not a schedule in the active document.");
+        if (schedule.IsTemplate) throw new ArgumentException("Schedule templates do not contain displayed body rows.");
+        using var table = schedule.GetTableData();
+        using var body = table.GetSectionData(SectionType.Body);
+        int columnOffset = Math.Max(0, JsonArgs.GetInt(args, "column_offset", 0));
+        int columnLimit = Math.Clamp(JsonArgs.GetInt(args, "column_limit", 50), 1, 50);
+        int columnCount = Math.Min(columnLimit, Math.Max(0, body.NumberOfColumns - columnOffset));
+        int rowCount = Math.Min(limit, Math.Max(0, body.NumberOfRows - offset));
+        var cells = Enumerable.Range(0, rowCount).Select(row => new
+        {
+            row_index = body.FirstRowNumber + offset + row,
+            cells = Enumerable.Range(0, columnCount).Select(col => schedule.GetCellText(SectionType.Body,
+                body.FirstRowNumber + offset + row, body.FirstColumnNumber + columnOffset + col)).ToArray(),
+        }).ToArray();
+        var fields = schedule.Definition.GetFieldOrder().Select(fieldId =>
+        {
+            var field = schedule.Definition.GetField(fieldId);
+            return new { field_id = fieldId.IntegerValue, parameter_id = field.ParameterId.Value,
+                name = field.GetName(), heading = field.ColumnHeading, hidden = field.IsHidden, field_type = field.FieldType.ToString(),
+                spec_type_id = field.GetSpecTypeId().TypeId, grid_width_feet = field.GridColumnWidth, sheet_width_feet = field.SheetColumnWidth,
+                can_filter_value = schedule.Definition.CanFilterByValue(fieldId), can_filter_substring = schedule.Definition.CanFilterBySubstring(fieldId) };
+        }).ToArray();
+        return new
+        {
+            schedule_id = id, name = schedule.Name, is_itemized = schedule.Definition.IsItemized, fields,
+            sort_fields = schedule.Definition.GetSortGroupFields().Select(sort => new { field_id = sort.FieldId.IntegerValue, order = sort.SortOrder.ToString(), show_header = sort.ShowHeader }).ToArray(),
+            filters = schedule.Definition.GetFilters().Select(filter => new { field_id = filter.FieldId.IntegerValue, comparison = filter.FilterType.ToString(),
+                value = filter.IsStringValue ? (object)filter.GetStringValue() : filter.IsDoubleValue ? filter.GetDoubleValue() : filter.IsIntegerValue ? filter.GetIntegerValue() : filter.IsElementIdValue ? filter.GetElementIdValue().Value : null,
+                value_unit = filter.IsDoubleValue ? "internal" : null }).ToArray(),
+            total_rows = body.NumberOfRows, total_columns = body.NumberOfColumns,
+            offset, returned_rows = rowCount,
+            next_offset = offset + rowCount < body.NumberOfRows ? (int?)(offset + rowCount) : null,
+            column_offset = columnOffset, returned_columns = columnCount,
+            first_column_index = body.FirstColumnNumber + columnOffset,
+            next_column_offset = columnOffset + columnCount < body.NumberOfColumns ? (int?)(columnOffset + columnCount) : null,
+            rows = cells,
+        };
+    }
+}

package/src/Revit/Tools/InheritedState.Summary.cs

@@ -0,0 +1,57 @@
+namespace RevitBridge.Tools
+{
+    /// <summary>The Revit-free part of InheritedState: limits, the facts record and the summary. Tested offline.</summary>
+    internal static partial class InheritedState
+    {
+        public const int ListCap = 30;
+        public const int SampleCap = 10;
+        public static readonly TimeSpan ScanBudget = TimeSpan.FromSeconds(4);
+
+        public const string ViewCheck = "Inherited from the source view. Compare this state with the request: show anything the request asks to show, or disclose what stays hidden, and report what was inherited.";
+        public const string NewViewCheck = "A new view starts with this visibility state; a duplicate inherits its source's state. Compare it with the request before reporting the view as complete.";
+        public const string ElementCheck = "Carried over from the source object. Check these values against the request; a copied Mark or Comment usually needs a new value.";
+
+        /// <summary>Facts read from one view. Lists hold category identities as "OST_Name|Localized name".</summary>
+        internal sealed record ViewFacts(
+            long? SourceId, long? TemplateId, string? TemplateName,
+            IReadOnlyList<string> HiddenCategories, int HiddenElementCount, IReadOnlyList<long> HiddenElementSample,
+            int ElementOverrideCount, bool ElementScanComplete, int CategoryOverrideCount,
+            IReadOnlyList<(long Id, string Name, bool Visible)> Filters, bool TemporaryHideIsolate,
+            string? DisplayStyle, string? DetailLevel, bool CropActive, bool? SectionBoxActive, bool? Perspective);
+
+        /// <summary>Pure summary of view facts: only non-empty sections, capped lists, and the check the caller must make.</summary>
+        public static Dictionary<string, object?> Summarize(ViewFacts facts, string check)
+        {
+            var state = new Dictionary<string, object?>();
+            if (facts.SourceId is long source) state["derived_from"] = source;
+            if (facts.TemplateId is long template && template > 0) state["template"] = new Dictionary<string, object?> { ["id"] = template, ["name"] = facts.TemplateName };
+            if (facts.HiddenCategories.Count > 0)
+                state["hidden_categories"] = new Dictionary<string, object?>
+                {
+                    ["count"] = facts.HiddenCategories.Count,
+                    ["categories"] = facts.HiddenCategories.Take(ListCap).ToList(),
+                    ["truncated"] = facts.HiddenCategories.Count > ListCap,
+                };
+            if (facts.HiddenElementCount > 0 || !facts.ElementScanComplete)
+                state["hidden_elements"] = new Dictionary<string, object?>
+                {
+                    ["count"] = facts.HiddenElementCount,
+                    ["sample_ids"] = facts.HiddenElementSample.Take(SampleCap).ToList(),
+                    ["complete"] = facts.ElementScanComplete,
+                };
+            if (facts.ElementOverrideCount > 0) state["element_overrides"] = facts.ElementOverrideCount;
+            if (facts.CategoryOverrideCount > 0) state["category_overrides"] = facts.CategoryOverrideCount;
+            if (facts.Filters.Count > 0)
+                state["filters"] = facts.Filters.Take(ListCap).Select(f => new Dictionary<string, object?> { ["id"] = f.Id, ["name"] = f.Name, ["visible"] = f.Visible }).ToList();
+            if (facts.TemporaryHideIsolate) state["temporary_hide_isolate"] = true;
+            var display = new Dictionary<string, object?> { ["display_style"] = facts.DisplayStyle, ["detail_level"] = facts.DetailLevel, ["crop_box_active"] = facts.CropActive };
+            if (facts.SectionBoxActive is bool box) display["section_box_active"] = box;
+            if (facts.Perspective is bool perspective) display["perspective"] = perspective;
+            state["display"] = display;
+            if (!facts.ElementScanComplete)
+                state["scan_note"] = $"The hidden-element scan stopped after {ScanBudget.TotalSeconds:0} s; counts are lower bounds.";
+            state["check"] = check;
+            return state;
+        }
+    }
+}

package/src/Revit/Tools/InheritedState.cs

@@ -0,0 +1,144 @@
+using System.Diagnostics;
+using Autodesk.Revit.DB;
+
+namespace RevitBridge.Tools
+{
+    /// <summary>
+    /// Shared report of the state an object carries when it is derived from an existing one
+    /// (inv:derived-state-reported). A duplicated view keeps its source's hidden categories and
+    /// elements, filters, overrides and template; a copied element keeps its instance values; a
+    /// retyped element keeps its per-view graphics. Any tool that duplicates, copies, mirrors or
+    /// retypes reports this in its result, so the caller can compare it with the request instead
+    /// of relying on an image. The gate in scripts/check-tool-documentation.mjs makes every tool
+    /// that creates from an existing object use this class. Reading and summarizing are separate:
+    /// Summarize is pure and tested offline; the Read* methods only collect facts from Revit.
+    /// </summary>
+    internal static partial class InheritedState
+    {
+        /// <summary>Inherited state of a view derived from source (null when unknown), for a result.</summary>
+        public static Dictionary<string, object?> OfView(View view, long? sourceId, string check = ViewCheck)
+            => Summarize(ReadView(view, sourceId), check);
+
+        /// <summary>Collect facts from Revit. The element scan is bounded by ScanBudget.</summary>
+        public static ViewFacts ReadView(View view, long? sourceId)
+        {
+            var doc = view.Document;
+            var hiddenCategories = new List<string>();
+            int categoryOverrides = 0;
+            foreach (Category category in doc.Settings.Categories)
+            {
+                try
+                {
+                    if (view.CanCategoryBeHidden(category.Id) && view.GetCategoryHidden(category.Id))
+                        hiddenCategories.Add($"{category.BuiltInCategory}|{category.Name}");
+                    if (view.AreGraphicsOverridesAllowed() && view.IsCategoryOverridable(category.Id) && IsNonDefault(view.GetCategoryOverrides(category.Id)))
+                        categoryOverrides++;
+                }
+                catch (Autodesk.Revit.Exceptions.ArgumentException) { }
+            }
+
+            int hidden = 0, overridden = 0;
+            var sample = new List<long>();
+            bool complete = true;
+            var clock = Stopwatch.StartNew();
+            var candidates = new FilteredElementCollector(doc).WhereElementIsNotElementType().WhereElementIsViewIndependent()
+                .Concat(new FilteredElementCollector(doc).OwnedByView(view.Id));
+            foreach (var element in candidates)
+            {
+                if (clock.Elapsed > ScanBudget) { complete = false; break; }
+                try
+                {
+                    if (element.CanBeHidden(view) && element.IsHidden(view))
+                    {
+                        hidden++;
+                        if (sample.Count < SampleCap) sample.Add(element.Id.Value);
+                    }
+                    if (view.AreGraphicsOverridesAllowed() && IsNonDefault(view.GetElementOverrides(element.Id))) overridden++;
+                }
+                catch (Autodesk.Revit.Exceptions.ArgumentException) { }
+                catch (Autodesk.Revit.Exceptions.InvalidOperationException) { }
+            }
+
+            var filters = new List<(long, string, bool)>();
+            try
+            {
+                foreach (var id in view.GetFilters())
+                    filters.Add((id.Value, doc.GetElement(id)?.Name ?? "", view.GetFilterVisibility(id)));
+            }
+            catch (Autodesk.Revit.Exceptions.InvalidOperationException) { }
+
+            var template = view.ViewTemplateId;
+            var view3D = view as View3D;
+            return new ViewFacts(sourceId, template.Value > 0 ? template.Value : null, template.Value > 0 ? doc.GetElement(template)?.Name : null,
+                hiddenCategories, hidden, sample, overridden, complete, categoryOverrides, filters, Safe(() => view.IsTemporaryHideIsolateActive()),
+                Safe(() => view.DisplayStyle.ToString()), Safe(() => view.DetailLevel.ToString()), Safe(() => view.CropBoxActive),
+                view3D == null ? null : Safe(() => view3D.IsSectionBoxActive), view3D?.IsPerspective);
+        }
+
+        /// <summary>Some view kinds (schedules, sheets) reject graphics properties; report them as unset.</summary>
+        private static T? Safe<T>(Func<T> read)
+        {
+            try { return read(); }
+            catch (Autodesk.Revit.Exceptions.InvalidOperationException) { return default; }
+            catch (Autodesk.Revit.Exceptions.ArgumentException) { return default; }
+        }
+
+        /// <summary>True when an override changes anything from the view's normal graphics.</summary>
+        public static bool IsNonDefault(OverrideGraphicSettings o) =>
+            o.Halftone || o.Transparency != 0 || o.DetailLevel != ViewDetailLevel.Undefined
+            || o.ProjectionLineColor.IsValid || o.ProjectionLineWeight != OverrideGraphicSettings.InvalidPenNumber
+            || o.CutLineColor.IsValid || o.CutLineWeight != OverrideGraphicSettings.InvalidPenNumber
+            || o.SurfaceForegroundPatternId != ElementId.InvalidElementId || o.CutForegroundPatternId != ElementId.InvalidElementId
+            || !o.IsSurfaceForegroundPatternVisible || !o.IsCutForegroundPatternVisible;
+
+        /// <summary>
+        /// Inherited state of an element derived from source: its special traits, identity-like
+        /// values that were copied (Mark, Comments), and views that hide or override it (bounded).
+        /// Per-view hiding and overrides are keyed by element ID, so a copy (new ID) never inherits
+        /// them; pass viewGraphics only when the element keeps its ID, as a retyped element does.
+        /// Views get the view report instead. Returns null when nothing was carried over.
+        /// </summary>
+        public static Dictionary<string, object?>? OfElement(Element derived, long? sourceId, bool viewGraphics = false)
+        {
+            if (derived is View view) return OfView(view, sourceId);
+            var state = new Dictionary<string, object?>();
+            if (sourceId is long source && source != derived.Id.Value) state["derived_from"] = source;
+            if (ElementTraits.For(derived) is { } traits) state["traits"] = traits;
+            var carried = new Dictionary<string, object?>();
+            foreach (var (key, parameter) in new[] { ("mark", BuiltInParameter.ALL_MODEL_MARK), ("comments", BuiltInParameter.ALL_MODEL_INSTANCE_COMMENTS) })
+                if (derived.get_Parameter(parameter)?.AsString() is { Length: > 0 } value) carried[key] = value;
+            if (carried.Count > 0) state["carried_values"] = carried;
+            if (viewGraphics && ViewGraphicsOf(derived) is { } graphics) state["view_graphics"] = graphics;
+            if (state.Count == 0 || (state.Count == 1 && state.ContainsKey("derived_from"))) return null;
+            state["check"] = ElementCheck;
+            return state;
+        }
+
+        /// <summary>Views that hide or override this element, within ScanBudget.</summary>
+        private static Dictionary<string, object?>? ViewGraphicsOf(Element element)
+        {
+            var clock = Stopwatch.StartNew();
+            var hiddenIn = new List<long>();
+            int overriddenIn = 0;
+            bool complete = true;
+            foreach (var view in new FilteredElementCollector(element.Document).OfClass(typeof(View)).Cast<View>())
+            {
+                if (clock.Elapsed > ScanBudget) { complete = false; break; }
+                if (view.IsTemplate) continue;
+                try
+                {
+                    if (element.CanBeHidden(view) && element.IsHidden(view)) hiddenIn.Add(view.Id.Value);
+                    if (view.AreGraphicsOverridesAllowed() && IsNonDefault(view.GetElementOverrides(element.Id))) overriddenIn++;
+                }
+                catch (Autodesk.Revit.Exceptions.ArgumentException) { }
+                catch (Autodesk.Revit.Exceptions.InvalidOperationException) { }
+            }
+            if (hiddenIn.Count == 0 && overriddenIn == 0 && complete) return null;
+            return new Dictionary<string, object?>
+            {
+                ["hidden_in_views"] = hiddenIn.Count, ["hidden_in_view_ids"] = hiddenIn.Take(SampleCap).ToList(),
+                ["overridden_in_views"] = overriddenIn, ["complete"] = complete,
+            };
+        }
+    }
+}

package/src/Revit/Tools/ManageElementSets.cs

@@ -0,0 +1,114 @@
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using Autodesk.Revit.DB;
+
+namespace RevitBridge.Tools;
+
+internal sealed class ManageElementSets : ITool
+{
+    private sealed record Member(long Id, string UniqueId);
+    private sealed record Snapshot(string Id, string DocumentId, string Label, DateTimeOffset Expires, IReadOnlyList<Member> Members);
+    private static readonly Dictionary<string, Snapshot> Sets = new(StringComparer.Ordinal);
+    private const int MaxElements = 10000;
+    private const int MaxSets = 32;
+
+    public string Name => "manage_element_sets";
+    public IReadOnlyList<string> DocumentKinds => DocumentKind.Both;
+    public IReadOnlyList<string> Keywords => new[] { "set", "collection", "remember elements", "saved query", "reread members", "snapshot" };
+    public IReadOnlyList<ToolLimit> Limits => new[]
+    {
+        new ToolLimit("Saved Revit selection sets", "api", "SelectionFilterElement.Create"),
+        new ToolLimit("Live query subscriptions", "tool", "get_elements (run the query again)"),
+    };
+    public string? Verification => "none";
+    public string Label => "Manage Element Sets";
+    public string Tier => "advanced";
+    public IReadOnlyList<string> Effects => new[] { "session" };
+    public string Description => "Create, list, read or forget reusable element sets without changing the model or selection. A set captures matching host-element identities (up to 10,000), expires after 30 minutes, and is valid only for the exact open document and bridge session. Read pages report live values, deleted members and identity mismatches; membership is a snapshot and filters are not re-evaluated. At most 32 sets are retained. Use read IDs with ordinary tools after checking missing members.";
+    public object ParametersSchema => new
+    {
+        type = "object",
+        properties = new
+        {
+            action = new { type = "string", @enum = new[] { "create", "list", "read", "forget" } },
+            query = ElementQueryScope.Schema(),
+            label = new { type = "string", maxLength = 160 },
+            set_id = new { type = "string" },
+            offset = new { type = "integer", minimum = 0 },
+            limit = new { type = "integer", minimum = 1, maximum = 1000 },
+            parameter_names = new { type = "array", maxItems = 20, items = new { type = "string" } },
+            include_type_parameters = new { type = "boolean" },
+        },
+        required = new[] { "action" },
+    };
+
+    public object Execute(JsonElement args, ToolContext context)
+    {
+        var doc = context.Document ?? throw new NoActiveDocumentException();
+        string documentId = DocumentGuard.GetIdentity(doc);
+        var now = DateTimeOffset.UtcNow;
+        foreach (var expired in Sets.Where(pair => pair.Value.Expires <= now).Select(pair => pair.Key).ToArray()) Sets.Remove(expired);
+        string action = JsonArgs.GetString(args, "action") ?? "";
+        if (action == "list") return new
+        {
+            sets = Sets.Values.Where(set => set.DocumentId == documentId).OrderBy(set => set.Expires)
+                .Select(set => new { set_id = set.Id, label = set.Label, total_count = set.Members.Count, expires_at = set.Expires }).ToArray(),
+        };
+        if (action == "create")
+        {
+            if (Sets.Count >= MaxSets) throw new ArgumentException("Element-set capacity reached. Forget an existing set or wait for expiry.");
+            string label = JsonArgs.GetString(args, "label") ?? "Element set";
+            if (label.Length > 160) throw new ArgumentException("label must be at most 160 characters.");
+            var query = ElementQueryScope.Parse(args);
+            query["fields"] = new JsonArray("id"); query["count_only"] = true;
+            JsonElement Query() => JsonSerializer.SerializeToElement(((ToolOutput)new GetElements().Execute(JsonSerializer.SerializeToElement(query), context)!).Payload);
+            var count = Query();
+            int total = count.GetProperty("total_count").GetInt32();
+            if (total > MaxElements) throw new ArgumentException($"Query matches {total} elements; narrow the scope to at most {MaxElements}.");
+            query["count_only"] = false; query["limit"] = 1000;
+            var members = new List<Member>(total);
+            for (int offset = 0; offset < total; offset += 1000)
+            {
+                query["offset"] = offset;
+                foreach (var row in Query().GetProperty("elements").EnumerateArray())
+                {
+                    var element = doc.GetElement(new ElementId(row.GetProperty("id").GetInt64()));
+                    members.Add(new Member(element.Id.Value, element.UniqueId));
+                }
+            }
+            var snapshot = new Snapshot(Guid.NewGuid().ToString("N"), documentId, label, now.AddMinutes(30), members);
+            Sets.Add(snapshot.Id, snapshot);
+            return new { set_id = snapshot.Id, document_id = documentId, label, total_count = total, expires_at = snapshot.Expires,
+                warnings = count.TryGetProperty("warnings", out var warnings) ? (object)warnings.Clone() : null };
+        }
+        if (action is not ("read" or "forget")) throw new ArgumentException("Unknown action; use create, list, read or forget.");
+        string setId = JsonArgs.GetString(args, "set_id") ?? "";
+        if (!Sets.TryGetValue(setId, out var saved)) throw new ArgumentException("Unknown or expired set_id. Create a fresh set; IDs do not survive a bridge restart.");
+        if (saved.DocumentId != documentId) throw new ArgumentException("This element set belongs to a different open document. Activate its original document or create a fresh set.");
+        if (action == "forget") { Sets.Remove(setId); return new { set_id = setId, forgotten = true }; }
+        int start = Math.Max(0, JsonArgs.GetInt(args, "offset", 0));
+        int limit = Math.Clamp(JsonArgs.GetInt(args, "limit", 100), 1, 1000);
+        var names = JsonArgs.GetStringArray(args, "parameter_names");
+        if (names?.Count > 20) throw new ArgumentException("parameter_names allows at most 20 identities.");
+        bool includeType = JsonArgs.GetBool(args, "include_type_parameters", false);
+        var page = saved.Members.Skip(start).Take(limit).ToArray();
+        var rows = new List<object>();
+        var missing = new List<object>();
+        foreach (var member in page)
+        {
+            var element = doc.GetElement(new ElementId(member.Id));
+            if (element == null || element.UniqueId != member.UniqueId)
+            {
+                missing.Add(new { id = member.Id, unique_id = member.UniqueId, reason = element == null ? "deleted" : "identity_changed" });
+                continue;
+            }
+            var row = ElementIdentity.Build(doc, element, ElementIdentity.Fields);
+            row["unique_id"] = member.UniqueId;
+            if (names is { Count: > 0 }) row["parameters"] = GetElementDetails.ProjectParameters(doc, element, names, includeType);
+            rows.Add(row);
+        }
+        return new { set_id = setId, document_id = documentId, snapshot_count = saved.Members.Count, expires_at = saved.Expires,
+            offset = start, visited_count = page.Length, returned_count = rows.Count,
+            next_offset = start + page.Length < saved.Members.Count ? (int?)(start + page.Length) : null, elements = rows, missing };
+    }
+}

package/src/Revit/Tools/ManageSchedules.cs

@@ -0,0 +1,174 @@
+using System.Text.Json;
+using Autodesk.Revit.DB;
+
+namespace RevitBridge.Tools;
+
+internal sealed class ManageSchedules : ITool
+{
+    public string Name => "manage_schedules";
+    public IReadOnlyList<string> DocumentKinds => DocumentKind.ProjectOnly;
+    public IReadOnlyList<string> Keywords => new[] { "create schedule", "schedule", "add field", "sort", "filter schedule", "quantities", "takeoff" };
+    public IReadOnlyList<ToolLimit> Limits => new[]
+    {
+        new ToolLimit("Calculated (formula) fields", "revit_unsupported", "Revit 2025 API exposes ScheduleFieldType.Formula but no member to author a formula"),
+        new ToolLimit("Combined-parameter fields", "api", "ScheduleDefinition.InsertCombinedParameterField"),
+        new ToolLimit("Schedule templates, titleblock revision schedules and embedded schedules", "api", "ViewSchedule and ScheduleDefinition members; verify with search_api_docs"),
+        new ToolLimit("Placing a schedule on a sheet", "tool", "manage_sheet_placements"),
+    };
+    public string? Verification => "reread";
+    public string Label => "Manage Schedules";
+    public string Tier => "advanced";
+    public bool Write => true;
+    public string Description => "Create or configure a regular schedule in one atomic step. Create requires category and name; optional area_scheme_id supports area schedules. Configure requires schedule_id. Discover add_fields using get_schedule_fields and pass the returned parameter_id + field_type pair, including Count when listed. Count also supports field_type Count without a parameter_id. update_fields, sort_fields and filters use schedule-local field_id from get_schedules. Supplied sort_fields/filters replace their entire lists; empty arrays clear them. Numeric measured filter values require a compatible unit; returned numeric filter values use internal units. Column widths require explicit length units and apply to both grid and sheet. preview=true commit-validates then rolls back; created schedule/field IDs in previews are temporary. Revision schedules, templates, embedded schedules and calculated/combined-field authoring are outside this tool.";
+    public object ParametersSchema => new
+    {
+        type = "object", properties = new
+        {
+            action = new { type = "string", @enum = new[] { "create", "configure" } },
+            schedule_id = new { type = "integer", minimum = 1 }, category = new { type = "string" }, name = new { type = "string", minLength = 1 }, area_scheme_id = new { type = "integer", minimum = 1 },
+            is_itemized = new { type = "boolean" }, preview = ModelEditInputs.PreviewSchema,
+            add_fields = new { type = "array", maxItems = 50, items = new { type = "object", properties = new
+            {
+                parameter_id = new { type = "integer", description = "Use the ID returned by get_schedule_fields, including negative built-in IDs. Optional for Count; when supplied, the pair must be eligible for the schedule." }, field_type = new { type = "string" },
+                heading = new { type = "string" }, hidden = new { type = "boolean" }, width = new { type = "number", exclusiveMinimum = 0 }, unit = ModelEditInputs.LengthUnitSchema,
+            }, required = new[] { "field_type" } } },
+            update_fields = new { type = "array", maxItems = 50, items = new { type = "object", properties = new
+            {
+                field_id = new { type = "integer", minimum = 0 }, heading = new { type = "string" }, hidden = new { type = "boolean" }, width = new { type = "number", exclusiveMinimum = 0 }, unit = ModelEditInputs.LengthUnitSchema,
+            }, required = new[] { "field_id" } } },
+            sort_fields = new { type = "array", maxItems = 4, items = new { type = "object", properties = new { field_id = new { type = "integer", minimum = 0 }, descending = new { type = "boolean" }, show_header = new { type = "boolean" } }, required = new[] { "field_id" } } },
+            filters = new { type = "array", maxItems = 8, items = new { type = "object", properties = new
+            {
+                field_id = new { type = "integer", minimum = 0 }, comparison = new { type = "string", @enum = new[] { "equals", "not_equals", "contains", "greater_than", "less_than" } },
+                value_type = new { type = "string", @enum = new[] { "string", "number", "integer", "element_id" } }, value = new { description = "Filter value matching value_type." }, unit = new { type = "string", description = "Required for measured numbers; compatible forge unit name, e.g. meters, squareMeters, degrees." },
+            }, required = new[] { "field_id", "comparison", "value_type", "value" } } },
+        }, required = new[] { "action" },
+    };
+
+    public object Execute(JsonElement args, ToolContext context)
+    {
+        var doc = context.Document ?? throw new NoActiveDocumentException();
+        string action = JsonArgs.GetString(args, "action") ?? "";
+        if (action is not ("create" or "configure")) throw new ArgumentException("action must be create or configure.");
+        var additions = Array(args, "add_fields", 50); var updates = Array(args, "update_fields", 50);
+        var sorts = Array(args, "sort_fields", 4); var filters = Array(args, "filters", 8);
+        return ModelEditBatch.Run(doc, Name, args, new[] { new ModelEditBatch.Step(new() { ["action"] = action }, () =>
+        {
+            ViewSchedule schedule;
+            if (action == "create")
+            {
+                string category = JsonArgs.GetString(args, "category") ?? throw new ArgumentException("category is required for creation.");
+                var categoryId = CategoryResolver.Resolve(doc, category);
+                schedule = JsonArgs.GetLong(args, "area_scheme_id") is long area ? ViewSchedule.CreateSchedule(doc, categoryId, new ElementId(area)) : ViewSchedule.CreateSchedule(doc, categoryId);
+                if (!args.TryGetProperty("name", out _)) throw new ArgumentException("name is required for creation.");
+            }
+            else
+            {
+                if (args.TryGetProperty("category", out _) || args.TryGetProperty("area_scheme_id", out _)) throw new ArgumentException("category and area_scheme_id are creation-only.");
+                schedule = doc.GetElement(new ElementId(JsonArgs.GetLong(args, "schedule_id") ?? 0)) as ViewSchedule ?? throw new ArgumentException("schedule_id is not a schedule.");
+            }
+            if (schedule.IsTemplate || schedule.IsTitleblockRevisionSchedule || schedule.Definition.IsEmbedded) throw new ArgumentException("Use a regular, non-template schedule.");
+            if (args.TryGetProperty("name", out var name))
+            {
+                if (name.ValueKind != JsonValueKind.String || string.IsNullOrWhiteSpace(name.GetString())) throw new ArgumentException("name must be nonempty.");
+                ElementNames.Assign(schedule, name.GetString()!);
+            }
+            var definition = schedule.Definition;
+            var added = new List<int>();
+            foreach (var input in additions)
+            {
+                string typeName = JsonArgs.GetString(input, "field_type") ?? "";
+                if (typeName.Length == 0 || !char.IsLetter(typeName[0]) || !Enum.TryParse<ScheduleFieldType>(typeName, false, out var type) || !Enum.IsDefined(type)) throw new ArgumentException("Use a field_type from get_schedule_fields, or Count.");
+                ScheduleField field;
+                if (type == ScheduleFieldType.Count && !input.TryGetProperty("parameter_id", out _))
+                {
+                    field = definition.AddField(type);
+                }
+                else
+                {
+                    long parameterId = JsonArgs.GetLong(input, "parameter_id") ?? throw new ArgumentException("parameter_id is required for this field.");
+                    var eligible = definition.GetSchedulableFields().FirstOrDefault(f => f.ParameterId.Value == parameterId && f.FieldType == type) ?? throw new ArgumentException("That parameter_id/field_type pair is not eligible for this schedule.");
+                    field = definition.AddField(eligible);
+                }
+                ConfigureField(field, input); added.Add(field.FieldId.IntegerValue);
+            }
+            var seen = new HashSet<int>();
+            foreach (var input in updates)
+            {
+                var id = FieldId(input);
+                if (!seen.Add(id.IntegerValue)) throw new ArgumentException("update_fields contains a duplicate field_id.");
+                ConfigureField(definition.GetField(id), input);
+            }
+            if (args.TryGetProperty("is_itemized", out _)) definition.IsItemized = Bool(args, "is_itemized");
+            if (args.TryGetProperty("sort_fields", out _))
+                definition.SetSortGroupFields(sorts.Select(input => new ScheduleSortGroupField(FieldId(input), Bool(input, "descending") ? ScheduleSortOrder.Descending : ScheduleSortOrder.Ascending) { ShowHeader = Bool(input, "show_header") }).ToList());
+            if (args.TryGetProperty("filters", out _)) definition.SetFilters(filters.Select(input => Filter(definition, input)).ToList());
+            doc.Regenerate();
+            return new() { ["schedule_id"] = schedule.Id.Value, ["unique_id"] = schedule.UniqueId, ["name"] = schedule.Name,
+                ["created"] = action == "create", ["id_is_temporary"] = action == "create" && JsonArgs.GetBool(args, "preview", false),
+                ["added_field_ids"] = added, ["added_field_ids_are_temporary"] = JsonArgs.GetBool(args, "preview", false),
+                ["is_itemized"] = definition.IsItemized, ["field_count"] = definition.GetFieldCount(), ["filter_count"] = definition.GetFilterCount(), ["sort_count"] = definition.GetSortGroupFieldCount() };
+        }) }).Payload;
+    }
+
+    private static List<JsonElement> Array(JsonElement args, string name, int max)
+    {
+        if (!args.TryGetProperty(name, out var value)) return new();
+        if (value.ValueKind != JsonValueKind.Array || value.GetArrayLength() > max) throw new ArgumentException($"{name} must be an array of at most {max} entries.");
+        var items = value.EnumerateArray().ToList();
+        if (items.Any(item => item.ValueKind != JsonValueKind.Object)) throw new ArgumentException($"{name} entries must be objects.");
+        return items;
+    }
+    private static bool Bool(JsonElement args, string name)
+    {
+        if (!args.TryGetProperty(name, out var value)) return false;
+        if (value.ValueKind is not (JsonValueKind.True or JsonValueKind.False)) throw new ArgumentException($"{name} must be boolean.");
+        return value.GetBoolean();
+    }
+    private static ScheduleFieldId FieldId(JsonElement input)
+    {
+        long id = JsonArgs.GetLong(input, "field_id") ?? -1;
+        return id is >= 0 and <= int.MaxValue ? new ScheduleFieldId((int)id) : throw new ArgumentException("field_id must be a nonnegative schedule-local ID.");
+    }
+    private static void ConfigureField(ScheduleField field, JsonElement input)
+    {
+        if (input.TryGetProperty("heading", out var heading)) field.ColumnHeading = heading.ValueKind == JsonValueKind.String ? heading.GetString()! : throw new ArgumentException("heading must be a string.");
+        if (input.TryGetProperty("hidden", out _)) field.IsHidden = Bool(input, "hidden");
+        if (input.TryGetProperty("width", out _))
+        {
+            double width = ModelEditInputs.Number(input, "width") * ModelEditInputs.LengthScale(input);
+            if (width <= 0) throw new ArgumentException("Column width must be positive.");
+            field.GridColumnWidth = width; field.SheetColumnWidth = width;
+        }
+    }
+    private static ScheduleFilter Filter(ScheduleDefinition definition, JsonElement input)
+    {
+        var id = FieldId(input); var field = definition.GetField(id);
+        var comparison = JsonArgs.GetString(input, "comparison") switch
+        {
+            "equals" => ScheduleFilterType.Equal, "not_equals" => ScheduleFilterType.NotEqual, "contains" => ScheduleFilterType.Contains,
+            "greater_than" => ScheduleFilterType.GreaterThan, "less_than" => ScheduleFilterType.LessThan, _ => throw new ArgumentException("Unknown comparison."),
+        };
+        if (comparison == ScheduleFilterType.Contains ? !definition.CanFilterBySubstring(id) : !definition.CanFilterByValue(id)) throw new ArgumentException("This field does not support that filter operation.");
+        if (!input.TryGetProperty("value", out var value)) throw new ArgumentException("Filter value is required.");
+        string? type = JsonArgs.GetString(input, "value_type");
+        if (type == "string" && value.ValueKind == JsonValueKind.String) return new ScheduleFilter(id, comparison, value.GetString()!);
+        if (type == "integer" && value.ValueKind == JsonValueKind.Number && value.TryGetInt32(out int integer)) return new ScheduleFilter(id, comparison, integer);
+        if (type == "element_id" && value.ValueKind == JsonValueKind.Number && value.TryGetInt64(out long elementId)) return new ScheduleFilter(id, comparison, new ElementId(elementId));
+        if (type == "number")
+        {
+            double number = ModelEditInputs.Number(input, "value");
+            var spec = field.GetSpecTypeId(); string? unit = JsonArgs.GetString(input, "unit");
+            if (UnitUtils.IsMeasurableSpec(spec))
+            {
+                if (string.IsNullOrWhiteSpace(unit)) throw new ArgumentException("Measured numeric filters require an explicit unit.");
+                var unitId = UnitResolver.Resolve(unit);
+                if (!UnitUtils.IsValidUnit(spec, unitId)) throw new ArgumentException("Filter unit does not match the field's specification.");
+                number = UnitUtils.ConvertToInternalUnits(number, unitId);
+            }
+            else if (unit != null) throw new ArgumentException("This numeric field has no measurable unit.");
+            return new ScheduleFilter(id, comparison, number);
+        }
+        throw new ArgumentException("Filter value does not match value_type.");
+    }
+}

package/src/Revit/Tools/ManageSelection.cs

@@ -12,6 +12,15 @@ namespace RevitBridge.Tools
     internal sealed class ManageSelection : ITool
     {
         public string Name => "manage_selection";
+        public IReadOnlyList<string> DocumentKinds => DocumentKind.Both;
+        public IReadOnlyList<string> Keywords => new[] { "select", "highlight", "zoom", "isolate", "show in revit", "selected elements", "current selection" };
+        public IReadOnlyList<ToolLimit> Limits => new[]
+        {
+            new ToolLimit("Permanent hiding or view visibility changes", "api", "View.HideElements; View.SetCategoryHidden"),
+            new ToolLimit("Saved selection sets", "api", "SelectionFilterElement.Create"),
+        };
+        public string? Verification => "reread";
+        public IReadOnlyList<string> Effects => new[] { "ui", "model" };
         public string Label => "Manage Selection";
         public string Description => "Manage the Revit selection and view focus. action 'get' returns the currently selected elements (id, name, category, typeName, levelId); 'set'/'add'/'remove' change the selection with element_ids; 'clear' empties it; 'zoom' zooms open views to element_ids (default: the current selection). isolate_in_view=true additionally applies Revit's Temporary Hide/Isolate to the affected elements in the active view — temporary view state, not a model change (Revit needs a brief internal transaction to toggle it); with an empty target set (action 'clear', or 'get' with nothing selected) it resets the temporary isolate instead. Selection and zoom never modify model data.";