get_file_skeleton never descends into matched declarations; most C# files collapse to one line #37

diff --git a/src/__tests__/chunker/skeleton.test.ts b/src/__tests__/chunker/skeleton.test.ts
index d234109..20fa540 100644
--- a/src/__tests__/chunker/skeleton.test.ts
+++ b/src/__tests__/chunker/skeleton.test.ts
@@ -18,6 +18,71 @@ describe("extractSkeleton", () => {
     );
   });
 
+  it("descends into matched declarations for a member-level outline", async () => {
+    // The chunker intentionally stops at the first matched declaration so one
+    // declaration stays one chunk; the skeleton must descend so members are
+    // reported. Regression: C# files used to collapse to a single class line.
+    const source = [
+      "public class Example",
+      "{",
+      "  public Example() {}",
+      "  public void Run() {}",
+      "  public string Name { get; set; }",
+      "  private int _count;",
+      "}",
+    ].join("\n");
+    const items = await extractSkeleton(source, ".cs");
+    assert.ok(
+      items.some((i) => i.type === "class_declaration"),
+      `expected the class, got: ${JSON.stringify(items)}`,
+    );
+    assert.ok(
+      items.some((i) => i.type === "constructor_declaration"),
+      `expected the constructor, got: ${JSON.stringify(items)}`,
+    );
+    assert.ok(
+      items.some((i) => i.type === "method_declaration"),
+      `expected the method, got: ${JSON.stringify(items)}`,
+    );
+    assert.ok(
+      items.some((i) => i.type === "property_declaration"),
+      `expected the property, got: ${JSON.stringify(items)}`,
+    );
+    assert.equal(
+      items.some((i) => i.type === "field_declaration"),
+      false,
+      "fields are intentionally excluded from the outline",
+    );
+  });
+
+  it("includes C# contract members but excludes data members", () => {
+    const types = SKELETON_CONFIGS[".cs"]!.nodeTypes;
+    for (const type of [
+      "property_declaration",
+      "record_declaration",
+      "delegate_declaration",
+      "event_field_declaration",
+      "event_declaration",
+      "indexer_declaration",
+      "operator_declaration",
+      "conversion_operator_declaration",
+      "destructor_declaration",
+      "constructor_declaration",
+    ]) {
+      assert.ok(types.includes(type), `expected ${type} in the .cs recipe`);
+    }
+    for (const type of [
+      "field_declaration",
+      "enum_member_declaration",
+      "using_directive",
+      "namespace_declaration",
+      "accessor_declaration",
+      "local_function_statement",
+    ]) {
+      assert.equal(types.includes(type), false, `did not expect ${type} in the .cs recipe`);
+    }
+  });
+
   it("keeps per-extension recipes that differ (.tsx includes arrow functions)", async () => {
     const source = "const App = () => 1;\n";
     const tsxItems = await extractSkeleton(source, ".tsx");
diff --git a/src/chunker/grammar.ts b/src/chunker/grammar.ts
index 039d02e..16dc2d1 100644
--- a/src/chunker/grammar.ts
+++ b/src/chunker/grammar.ts
@@ -307,6 +307,9 @@ function extractDocstringFromBody(
  * @param source - Full source text (used to slice node text and comments).
  * @param maxDepth - Maximum recursion depth (default: 10).
  * @param depth - Current recursion depth (internal, start at 0).
+ * @param descend - When true, continue into a matched node's children. The
+ *   chunker keeps the default so one matched declaration stays one chunk; the
+ *   skeleton outline sets it so members inside a declaration are reported.
  * @returns An array of {@link AstNode} objects for matching declarations.
  */
 export function walkTree(
@@ -316,6 +319,7 @@ export function walkTree(
   maxDepth: number = 10,
   depth: number = 0,
   offsetMap?: Map<number, number> | null,
+  descend: boolean = false,
 ): AstNode[] {
   const results: AstNode[] = [];
 
@@ -335,13 +339,15 @@ export function walkTree(
       type: node.type,
       leadingDoc: leadingDoc.length > 0 ? leadingDoc : undefined,
     });
-    return results;
+    // The chunker stops at the first matched declaration so that one
+    // declaration produces one chunk. The skeleton opts into descending.
+    if (!descend) return results;
   }
 
   if (depth < maxDepth) {
     for (const child of node.children) {
       results.push(
-        ...walkTree(child, nodeTypes, source, maxDepth, depth + 1, offsetMap)
+        ...walkTree(child, nodeTypes, source, maxDepth, depth + 1, offsetMap, descend)
       );
     }
   }
diff --git a/src/chunker/skeleton.ts b/src/chunker/skeleton.ts
index 6503a46..192c801 100644
--- a/src/chunker/skeleton.ts
+++ b/src/chunker/skeleton.ts
@@ -42,7 +42,7 @@ export const SKELETON_CONFIGS: Record<string, SkeletonConfig> = {
   ".cxx":   { grammarName: "cpp", nodeTypes: ["function_definition", "class_specifier", "struct_specifier", "enum_specifier"] },
   ".h":     { grammarName: "cpp", nodeTypes: ["function_definition", "class_specifier", "struct_specifier", "enum_specifier"] },
   ".hpp":   { grammarName: "cpp", nodeTypes: ["function_definition", "class_specifier", "struct_specifier", "enum_specifier"] },
-  ".cs":    { grammarName: "c_sharp", nodeTypes: ["class_declaration", "method_declaration", "interface_declaration", "enum_declaration", "struct_declaration"] },
+  ".cs":    { grammarName: "c_sharp", nodeTypes: ["class_declaration", "struct_declaration", "interface_declaration", "enum_declaration", "record_declaration", "delegate_declaration", "constructor_declaration", "destructor_declaration", "method_declaration", "property_declaration", "indexer_declaration", "event_field_declaration", "event_declaration", "operator_declaration", "conversion_operator_declaration"] },
   ".rb":    { grammarName: "ruby", nodeTypes: ["method", "class", "module"] },
   ".swift": { grammarName: "swift", nodeTypes: ["function_declaration", "class_declaration", "struct_declaration", "enum_declaration", "protocol_declaration"] },
   ".kt":    { grammarName: "kotlin", nodeTypes: ["function_declaration", "class_declaration", "interface_declaration", "object_declaration"] },
@@ -183,7 +183,8 @@ export async function extractSkeleton(
 
   try {
     const nodeTypes = new Set(config.nodeTypes);
-    const astNodes: AstNode[] = walkTree(tree.rootNode, nodeTypes, content, 15);
+    // Descend into matched declarations to produce a member-level outline.
+    const astNodes: AstNode[] = walkTree(tree.rootNode, nodeTypes, content, 15, 0, undefined, true);
     return astNodes.map((node) => ({
       type: node.type,
       name: extractNodeName(node.text, node.type),