Merge branch 'copilot/refactor-startcore-method-arguments' into copilot/add-standard-input-output-properties

Author: adamsitnik

.github/copilot-instructions.md

@@ -46,6 +46,15 @@ When NOT running under CCA, guidance for creating commits and pushing changes:
 - Never push to an active PR without being explicitly asked, even in autopilot/yolo mode. Always wait for explicit instruction to push.
 - Never chain commit and push in the same command. Always commit first, report what was committed, then wait for an explicit push instruction. This creates a mandatory decision point.
 - Prefer creating a new commit rather than amending an existing one. Exceptions: (1) explicitly asked to amend, or (2) the existing commit is obviously broken with something minor (e.g., typo or comment fix) and hasn't been pushed yet.
+- **Before posting to GitHub (PRs, issues, comments):** Include the AI-generated content disclosure (see below).
+
+## AI-Generated Content Disclosure
+
+When posting any content to GitHub under a user's credentials — opening PRs, creating issues, commenting on PRs or issues, posting review comments, or any other public-facing action — and the account is **not** a dedicated "copilot" or "bot" account/app, you **MUST** include a concise, visible note (e.g. a `> [!NOTE]` alert) indicating the content was AI/Copilot-generated.
+
+This applies to all GitHub interactions: PR descriptions, issue bodies, comments, review comments, etc. Exceptions:
+- The account is a recognized bot or Copilot app account (e.g., `github-actions[bot]`, `copilot`), where the AI origin is already apparent from the account identity.
+- The user explicitly asks you to omit the disclosure.
 
 ---
 

.github/skills/api-proposal/SKILL.md

@@ -270,12 +270,7 @@ Present the complete draft to the user for review. Iterate based on feedback bef
 
 ### Phase 5: Publish
 
-> **Agent disclaimer:** When publishing to GitHub on behalf of a user account, prepend the following disclaimer to the proposal body:
->
-> ```markdown
-> > [!NOTE]
-> > This proposal was drafted with the help of an AI agent. Please review for accuracy and remove this notice once you're satisfied with the content.
-> ```
+> **AI-generated content disclosure:** When posting any content to GitHub (issue body, PR body, comments) under a user's credentials — i.e., the account is **not** a dedicated "copilot" or "bot" account/app — prepend a concise, visible note (e.g. a `> [!NOTE]` alert) indicating the content was AI/Copilot-generated. This applies to the initial proposal, iteration updates, and any follow-up comments posted on the user's behalf. Skip this if the user explicitly asks you to omit it.
 
 #### Step 1: Push and capture commit URL
 

.github/skills/ci-analysis/SKILL.md

@@ -9,6 +9,8 @@ Analyze CI build status and test failures in Azure DevOps and Helix for dotnet r
 
 > 🚨 **NEVER** use `gh pr review --approve` or `--request-changes`. Only `--comment` is allowed. Approval and blocking are human-only actions.
 
+> 📝 **AI-generated content disclosure:** When posting any content to GitHub (PR comments, retry commands, analysis summaries) under a user's credentials — i.e., the account is **not** a dedicated "copilot" or "bot" account/app — you **MUST** include a concise, visible note (e.g. a `> [!NOTE]` alert) indicating the content was AI/Copilot-generated. Skip this if the user explicitly asks you to omit it.
+
 **Workflow**: Gather PR context (Step 0) → run the script → read the human-readable output + `[CI_ANALYSIS_SUMMARY]` JSON → synthesize recommendations yourself. The script collects data; you generate the advice. For supplementary investigation beyond the script, MCP tools (AzDO, Helix, GitHub) provide structured access when available; the script and `gh` CLI work independently when they're not.
 
 ## When to Use This Skill

.github/skills/code-review/SKILL.md

@@ -98,6 +98,8 @@ When the environment supports launching sub-agents with different models (e.g.,
 
 When presenting the final review (whether as a PR comment or as output to the user), use the following structure. This ensures consistency across reviews and makes the output easy to scan.
 
+> 📝 **AI-generated content disclosure:** When posting review content to GitHub (PR review comments, PR comments) under a user's credentials — i.e., the account is **not** a dedicated "copilot" or "bot" account/app — you **MUST** include a concise, visible note (e.g. a `> [!NOTE]` alert) indicating the content was AI/Copilot-generated. Skip this if the user explicitly asks you to omit it.
+
 ### Structure
 
 ```

.github/skills/issue-triage/SKILL.md

@@ -461,6 +461,12 @@ Key points:
   with these explicit instructions; the constraint above prevents *autonomous*
   actions before the human decision, not user-directed actions after it.
 
+  When posting any content to GitHub (issue comments, label changes with explanations)
+  under a user's credentials -- i.e., the account is **not** a dedicated "copilot"
+  or "bot" account/app -- you **MUST** include a concise, visible note (e.g. a
+  `> [!NOTE]` alert) indicating the content was AI/Copilot-generated. Skip this if
+  the user explicitly asks you to omit it.
+
 - **NEVER** use `gh issue close`, `gh issue edit`, `gh issue comment`, or
   `gh pr review --approve`/`--request-changes` **unless the user explicitly
   asks you to** after picking an outcome.

.github/skills/performance-benchmark/SKILL.md

@@ -125,12 +125,17 @@ public class Bench
 
 Post a comment on the PR to trigger EgorBot with your benchmark. The general format is:
 
+> 📝 **AI-generated content disclosure:** When posting benchmark comments to GitHub under a user's credentials — i.e., the account is **not** a dedicated "copilot" or "bot" account/app — you **MUST** include a concise, visible note (e.g. a `> [!NOTE]` alert) indicating the content was AI/Copilot-generated. Skip this if the user explicitly asks you to omit it.
+
 @EgorBot [targets] [options] [BenchmarkDotNet args]
 
 ```cs
 // Your benchmark code here
 ```
-> **Note:** The @EgorBot command must not be inside the code block. Only the benchmark code should be inside the code block.
+> **Note:** When using @EgorBot, follow these formatting rules:
+> - The @EgorBot command must not be inside the code block.
+> - Only the benchmark code should be inside the code block.
+> - Do not place any additional text between the @EgorBot command line and the code block, as EgorBot will treat it as additional command arguments.
 
 ### Target Flags
 

.github/skills/vmr-codeflow-status/SKILL.md

@@ -11,6 +11,8 @@ Analyze the health of VMR codeflow PRs in both directions:
 
 > 🚨 **NEVER** use `gh pr review --approve` or `--request-changes`. Only `--comment` is allowed. Approval and blocking are human-only actions.
 
+> 📝 **AI-generated content disclosure:** When posting any content to GitHub (PR comments, analysis summaries) under a user's credentials — i.e., the account is **not** a dedicated "copilot" or "bot" account/app — you **MUST** include a concise, visible note (e.g. a `> [!NOTE]` alert) indicating the content was AI/Copilot-generated. Skip this if the user explicitly asks you to omit it.
+
 **Workflow**: Run the script → read the human-readable output + `[CODEFLOW_SUMMARY]` JSON → synthesize recommendations yourself. The script collects data; you generate the advice.
 
 ## Prerequisites

docs/design/datacontracts/BuiltInCOM.md

@@ -13,6 +13,16 @@ public struct COMInterfacePointerData
     public TargetPointer MethodTable;
 }
 
+public struct SimpleComCallWrapperData
+{
+    public ulong RefCount;
+    public bool IsNeutered;
+    public bool IsAggregated;
+    public bool IsExtendsCOMObject;
+    public bool IsHandleWeak;
+    public TargetPointer OuterIUnknown;
+}
+
 public record struct RCWCleanupInfo(
     TargetPointer RCW,
     TargetPointer Context,
@@ -32,15 +42,20 @@ public record struct RCWData(
     bool IsFreeThreaded,
     bool IsDisconnected);
 
-public ulong GetRefCount(TargetPointer ccw);
-// Check whether the COM wrappers handle is weak.
-public bool IsHandleWeak(TargetPointer ccw);
 // Resolves a COM interface pointer to the ComCallWrapper.
 // Returns TargetPointer.Null if interfacePointer is not a recognised COM interface pointer.
+// Use GetStartWrapper on the result to navigate to the start of the chain.
 public TargetPointer GetCCWFromInterfacePointer(TargetPointer interfacePointer);
-// Enumerate the COM interfaces exposed by the ComCallWrapper chain.
+// Enumerates COM interfaces exposed by the ComCallWrapper chain.
 // ccw may be any ComCallWrapper in the chain; the implementation navigates to the start.
 public IEnumerable<COMInterfacePointerData> GetCCWInterfaces(TargetPointer ccw);
+// Returns the GC object handle from the given ComCallWrapper.
+public TargetPointer GetObjectHandle(TargetPointer ccw);
+// Returns the data stored in the SimpleComCallWrapper associated with the given ComCallWrapper.
+public SimpleComCallWrapperData GetSimpleComCallWrapperData(TargetPointer ccw);
+// Navigates to the start ComCallWrapper in a linked chain.
+// If ccw is already the start wrapper (or the only wrapper), returns ccw unchanged.
+public TargetPointer GetStartWrapper(TargetPointer ccw);
 // Enumerate entries in the RCW cleanup list.
 // If cleanupListPtr is Null, the global g_pRCWCleanupList is used.
 public IEnumerable<RCWCleanupInfo> GetRCWCleanupList(TargetPointer cleanupListPtr);
@@ -57,13 +72,15 @@ public RCWData GetRCWData(TargetPointer rcw);
 Data descriptors used:
 | Data Descriptor Name | Field | Meaning |
 | --- | --- | --- |
+| `ComCallWrapper` | `Handle` | GC object handle (`m_ppThis`); dereference to get the managed object pointer |
 | `ComCallWrapper` | `SimpleWrapper` | Address of the associated `SimpleComCallWrapper` |
 | `ComCallWrapper` | `IPtr` | Base address of the COM interface pointer array |
 | `ComCallWrapper` | `Next` | Next wrapper in the linked chain (all-bits-set sentinel = end of list) |
 | `ComMethodTable` | `Flags` | Flags word; bit `0x10` (`LayoutComplete`) must be set for valid vtable |
 | `ComMethodTable` | `MethodTable` | Pointer to the managed `MethodTable` for this COM interface |
-| `SimpleComCallWrapper` | `RefCount` | The wrapper refcount value |
-| `SimpleComCallWrapper` | `Flags` | Bit flags for wrapper properties |
+| `SimpleComCallWrapper` | `OuterIUnknown` | Outer `IUnknown` pointer for aggregated CCWs (`m_pOuter`) |
+| `SimpleComCallWrapper` | `RefCount` | The wrapper refcount value (includes `CLEANUP_SENTINEL` bit) |
+| `SimpleComCallWrapper` | `Flags` | Bit flags for wrapper properties (aggregated, extends-COM, handle-weak, etc.) |
 | `SimpleComCallWrapper` | `MainWrapper` | Pointer back to the first (start) `ComCallWrapper` in the chain |
 | `SimpleComCallWrapper` | `VTablePtr` | Base address of the standard interface vtable pointer array (used for SCCW IP resolution) |
 | `RCWCleanupList` | `FirstBucket` | Head of the bucket linked list |
@@ -87,7 +104,6 @@ Data descriptors used:
 Global variables used:
 | Global Name | Type | Purpose |
 | --- | --- | --- |
-| `ComRefcountMask` | `long` | Mask applied to `SimpleComCallWrapper.RefCount` to produce the visible refcount |
 | `CCWNumInterfaces` | `uint` | Number of vtable pointer slots in each `ComCallWrapper` (`NumVtablePtrs = 5`) |
 | `CCWThisMask` | `nuint` | Alignment mask applied to a standard CCW IP to recover the `ComCallWrapper` pointer |
 | `TearOffAddRef` | pointer | Address of `Unknown_AddRef`; identifies standard CCW interface pointers |
@@ -108,16 +124,26 @@ Contracts used:
 
 ``` csharp
 
-private enum CCWFlags
+// Mirrors enum SimpleComCallWrapperFlags in src/coreclr/vm/comcallablewrapper.h
+private enum SimpleComCallWrapperFlags : uint
 {
-    IsHandleWeak = 0x4,
+    IsAggregated  = 0x1,
+    IsExtendsCom  = 0x2,
+    IsHandleWeak  = 0x4,
 }
-
+// Mirrors enum Masks in src/coreclr/vm/comcallablewrapper.h
 private enum ComMethodTableFlags : ulong
 {
     LayoutComplete = 0x10,
 }
 
+[Flags]
+private enum ComRefCount : long
+{
+    ComRefCountMask           = 0x000000007FFFFFFFL,
+    CleanupSentinel          = 0x80000000L,
+}
+
 [Flags]
 private enum RCWFlags : uint
 {
@@ -127,21 +153,6 @@ private enum RCWFlags : uint
     MarshalingTypeFreeThreaded = 0x100u,
 }
 
-public ulong GetRefCount(TargetPointer address)
-{
-    var ccw = _target.ReadPointer(address + /* ComCallWrapper::SimpleWrapper offset */);
-    ulong refCount = _target.Read<ulong>(ccw + /* SimpleComCallWrapper::RefCount offset */);
-    long refCountMask = _target.ReadGlobal<long>("ComRefcountMask");
-    return refCount & (ulong)refCountMask;
-}
-
-public bool IsHandleWeak(TargetPointer address)
-{
-    var ccw = _target.ReadPointer(address + /* ComCallWrapper::SimpleWrapper offset */);
-    uint flags = _target.Read<uint>(ccw + /* SimpleComCallWrapper::Flags offset */);
-    return (flags & (uint)CCWFlags.IsHandleWeak) != 0;
-}
-
 // See ClrDataAccess::DACGetCCWFromAddress in src/coreclr/debug/daccess/request.cpp.
 // Resolves a COM interface pointer to the ComCallWrapper.
 // Returns TargetPointer.Null if interfacePointer is not a recognised COM IP.
@@ -158,6 +169,41 @@ public IEnumerable<COMInterfacePointerData> GetCCWInterfaces(TargetPointer ccw)
     //   - slot 0 of the first wrapper (IUnknown/IDispatch) yields null MethodTable
 }
 
+// Returns the GC object handle from the given ComCallWrapper.
+public TargetPointer GetObjectHandle(TargetPointer ccw)
+    => _target.ReadPointer(ccw + /* ComCallWrapper::Handle offset */);
+
+// Returns data from the SimpleComCallWrapper associated with the given ComCallWrapper.
+// Applies ComRefCountMask to produce the visible RefCount and checks CLEANUP_SENTINEL for IsNeutered.
+public SimpleComCallWrapperData GetSimpleComCallWrapperData(TargetPointer ccw)
+{
+    TargetPointer sccw = _target.ReadPointer(ccw + /* ComCallWrapper::SimpleWrapper offset */);
+    ulong rawRefCount = _target.Read<ulong>(sccw + /* SimpleComCallWrapper::RefCount offset */);
+    uint flags = _target.Read<uint>(sccw + /* SimpleComCallWrapper::Flags offset */);
+    return new SimpleComCallWrapperData
+    {
+        RefCount         = rawRefCount & ComRefCount.ComRefCountMask,
+        IsNeutered       = (rawRefCount & ComRefCount.CleanupSentinel) != 0,
+        IsAggregated     = (flags & (uint)SimpleComCallWrapperFlags.IsAggregated) != 0,
+        IsExtendsCOMObject = (flags & (uint)SimpleComCallWrapperFlags.IsExtendsCom) != 0,
+        IsHandleWeak     = (flags & (uint)SimpleComCallWrapperFlags.IsHandleWeak) != 0,
+        OuterIUnknown    = _target.ReadPointer(sccw + /* SimpleComCallWrapper::OuterIUnknown offset */),
+    };
+}
+
+// Navigates to the start ComCallWrapper in a linked chain.
+// If ccw is already the start wrapper (or the only wrapper), returns ccw unchanged.
+public TargetPointer GetStartWrapper(TargetPointer ccw)
+{
+    TargetPointer next = _target.ReadPointer(ccw + /* ComCallWrapper::Next offset */);
+    if (next != Null)
+    {
+        TargetPointer sccw = _target.ReadPointer(ccw + /* ComCallWrapper::SimpleWrapper offset */);
+        ccw = _target.ReadPointer(sccw + /* SimpleComCallWrapper::MainWrapper offset */);
+    }
+    return ccw;
+}
+
 public IEnumerable<RCWCleanupInfo> GetRCWCleanupList(TargetPointer cleanupListPtr)
 {
     // Resolve the cleanup list address.