code-context-control 2.95.0__tar.gz → 2.96.1__tar.gz

{code_context_control-2.95.0/code_context_control.egg-info → code_context_control-2.96.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.95.0
+Version: 2.96.1
 Summary: Local MCP code-intelligence for AI coding tools: surgical search/read/edit, agent-config version history, path-level access + masking guards, and a multi-project hub.
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0
@@ -149,7 +149,7 @@ Every C3-initialized project registers itself here on `c3 init`. Filter by activ
 
 Three top-level views — **Projects**, **Tasks** (a cross-project kanban), and **Credentials** — plus a drill-in panel per project covering Overview, Sub-projects, Tasks, Artifacts, Memory, Ledger, Sessions, Health, Budget, Credentials, Config, and MCP.
 
-**Sub-projects** make a nested repo a first-class child with its own `.c3`: the parent's index excludes the child's subtree, and `c3_search` / `c3_memory` fan out on demand (`scope='all'`, or one child by name). → [Sub-projects guide](https://github.com/drknowhow/code-context-control/blob/main/docs/sub-projects.md)
+**Sub-projects** make one project a first-class child of another, with its own `.c3`. It can be a nested repo — the parent's index then excludes its subtree — or a project anywhere else on disk, linked by path. Hierarchies nest up to 8 levels, and `c3_search` / `c3_memory` fan out on demand (`scope='all'`, or one by name). → [Sub-projects guide](https://github.com/drknowhow/code-context-control/blob/main/docs/sub-projects.md)
 
 ### Per-project UI
 
@@ -211,7 +211,7 @@ C3 exposes **21 tools** as a native MCP server. Your IDE calls them directly:
 | `c3_credentials` | Named-secret vault; values never enter model context (v2.58.0). `import_env` bulk-imports a `.env` the agent still cannot read (v2.93.0) |
 | `c3_bitbucket` | Bitbucket Data Center — PRs, branches, builds, admin (v2.30.0) |
 | `c3_jira` | Jira Cloud + Data Center — JQL, issues, transitions (v2.56.0) |
-| `c3_project` | Cross-project discovery & operations; guarded writes (v2.31.0) |
+| `c3_project` | Cross-project discovery & operations; sub-project hierarchy (link by path, inspect, multi-level tree); guarded writes (v2.31.0) |
 
 Every tool is **read-only safe in plan mode** except `c3_edit`, `c3_shell`, `c3_ci(action='run'|'rerun')`, `c3_artifacts(action='restore')`, `c3_delegate` with write delegation enabled, and write actions on `c3_bitbucket` / `c3_jira` / `c3_credentials` / `c3_project` / `c3_task` / `c3_locks`.
 

{code_context_control-2.95.0 → code_context_control-2.96.1}/README.md

@@ -86,7 +86,7 @@ Every C3-initialized project registers itself here on `c3 init`. Filter by activ
 
 Three top-level views — **Projects**, **Tasks** (a cross-project kanban), and **Credentials** — plus a drill-in panel per project covering Overview, Sub-projects, Tasks, Artifacts, Memory, Ledger, Sessions, Health, Budget, Credentials, Config, and MCP.
 
-**Sub-projects** make a nested repo a first-class child with its own `.c3`: the parent's index excludes the child's subtree, and `c3_search` / `c3_memory` fan out on demand (`scope='all'`, or one child by name). → [Sub-projects guide](https://github.com/drknowhow/code-context-control/blob/main/docs/sub-projects.md)
+**Sub-projects** make one project a first-class child of another, with its own `.c3`. It can be a nested repo — the parent's index then excludes its subtree — or a project anywhere else on disk, linked by path. Hierarchies nest up to 8 levels, and `c3_search` / `c3_memory` fan out on demand (`scope='all'`, or one by name). → [Sub-projects guide](https://github.com/drknowhow/code-context-control/blob/main/docs/sub-projects.md)
 
 ### Per-project UI
 
@@ -148,7 +148,7 @@ C3 exposes **21 tools** as a native MCP server. Your IDE calls them directly:
 | `c3_credentials` | Named-secret vault; values never enter model context (v2.58.0). `import_env` bulk-imports a `.env` the agent still cannot read (v2.93.0) |
 | `c3_bitbucket` | Bitbucket Data Center — PRs, branches, builds, admin (v2.30.0) |
 | `c3_jira` | Jira Cloud + Data Center — JQL, issues, transitions (v2.56.0) |
-| `c3_project` | Cross-project discovery & operations; guarded writes (v2.31.0) |
+| `c3_project` | Cross-project discovery & operations; sub-project hierarchy (link by path, inspect, multi-level tree); guarded writes (v2.31.0) |
 
 Every tool is **read-only safe in plan mode** except `c3_edit`, `c3_shell`, `c3_ci(action='run'|'rerun')`, `c3_artifacts(action='restore')`, `c3_delegate` with write delegation enabled, and write actions on `c3_bitbucket` / `c3_jira` / `c3_credentials` / `c3_project` / `c3_task` / `c3_locks`.
 

{code_context_control-2.95.0 → code_context_control-2.96.1}/cli/c3.py

@@ -92,7 +92,7 @@ console = Console() if HAS_RICH else None
 # Config
 CONFIG_DIR = ".c3"
 CONFIG_FILE = ".c3/config.json"
-__version__ = "2.95.0"
+__version__ = "2.96.1"
 
 
 def _compress_file_cli(compressor, path, mode="smart", **kw):
@@ -7986,14 +7986,117 @@ def cmd_sub(args):
         print(f"No .c3 found in {parent}. Run 'c3 init' there first.")
         return
     # Import after the cheap guard — the registry module needs a resolvable home.
-    from services.subprojects import VALID_CASCADE_OPS, SubprojectManager
+    from services.subprojects import (
+        MAX_DEPTH,
+        VALID_CASCADE_OPS,
+        SubprojectManager,
+        inspect_path,
+    )
 
     sm = SubprojectManager(parent)
     sub = getattr(args, "sub_cmd", "list") or "list"
     target = getattr(args, "target", None)
     as_json = getattr(args, "json", False)
+    depth = getattr(args, "depth", None) or MAX_DEPTH
 
-    if sub == "add":
+    if sub == "inspect":
+        if not target:
+            print("Usage: c3 sub inspect <path> [--json]")
+            return
+        rep = inspect_path(target, detect=not getattr(args, "no_detect", False))
+        if as_json:
+            print(json.dumps(rep, indent=2))
+            return
+        print(f"\n{rep['path']}")
+        if not rep["is_dir"]:
+            print("  not a folder")
+            return
+        proj = rep.get("project")
+        if proj:
+            reg = "registered" if rep["registered"] else "NOT registered"
+            print(f"  C3 project: {proj['name']}  (v{proj.get('c3_version') or '?'}, "
+                  f"ide={proj.get('ide') or '?'}, {reg})")
+            print(f"  {proj['facts_count']} facts, {proj['sessions']} sessions, "
+                  f"{proj['edit_ledger_entries']} ledger entries, "
+                  f"{proj['notification_count']} alerts")
+        else:
+            print("  no .c3 — not a C3 project yet")
+        if rep["ancestors"]:
+            chain = " < ".join(a["name"] for a in rep["ancestors"])
+            print(f"  parent chain (depth {rep['depth']}): {chain}")
+        else:
+            print("  top-level (no parent)")
+        if rep["children"]:
+            print(f"  {len(rep['children'])} sub-project(s):")
+            for c in rep["children"]:
+                print(f"    - {c['name']:<22} [{c['link_kind']}/{c['status']}]  {c['path']}")
+        if rep["detected"]:
+            print(f"  {len(rep['detected'])} unlinked project(s) detected inside:")
+            for d in rep["detected"]:
+                print(f"    ? {d['name']:<22} {d['path']}")
+            print("    (suggestions only — link with `c3 sub link <path>`)")
+        for w in rep["warnings"]:
+            print(f"  warning: {w}")
+
+    elif sub == "tree":
+        t = sm.tree(depth=depth)
+        if as_json:
+            print(json.dumps(t, indent=2))
+            return
+        r = t["rollup"]
+        print(f"\n{t['parent']['name']}  ({t['parent']['path']})")
+
+        def _render(rows, indent="  "):
+            for row in rows:
+                flag = "" if row["status"] == "ok" else f"  [{row['status']}]"
+                kind = "" if row["link_kind"] == "nested" else "  (linked)"
+                print(f"{indent}- {row['name']}{kind}{flag}")
+                _render(row.get("children") or [], indent + "    ")
+
+        _render(t["children"])
+        if not t["children"]:
+            print("  No sub-projects designated. Use `c3 sub link <path>`.")
+            return
+        line = f"\n{r['children']} descendant(s), {r['direct_children']} direct"
+        if r["issues"]:
+            line += f" -- {r['issues']} with issues (run `c3 sub check --fix`)"
+        print(line)
+
+    elif sub == "link":
+        if not target:
+            print("Usage: c3 sub link <path> [--parent PATH] [--name NAME] [--init]")
+            return
+        # link is designation for a project that already exists anywhere on
+        # disk; add is for a folder this parent should initialize.
+        want_init = getattr(args, "init", False)
+        candidate = target if Path(target).is_absolute() else str(Path(parent) / target)
+        probe = inspect_path(candidate, detect=False)
+        if probe["is_dir"] and not probe["has_c3"] and not want_init:
+            err = (f"not a C3 project: {probe['path']} — "
+                   "pass --init to initialize it, or run `c3 init` there first")
+            if as_json:
+                print(json.dumps({"added": False, "error": err}, indent=2))
+            else:
+                print(f"Failed: {err}")
+            return
+        result = sm.add(
+            target,
+            name=getattr(args, "name", None),
+            ide=getattr(args, "ide", None),
+            run_init=want_init,
+            reindex_parent=not getattr(args, "no_reindex_parent", False),
+        )
+        if as_json:
+            print(json.dumps(result, indent=2))
+            return
+        if not result.get("added"):
+            print(f"Failed: {result.get('error')}")
+            return
+        where = "by path" if result["link_kind"] == "external" else f"at {result['rel_path']}"
+        print(f"\n[OK] Linked {result['name']} {where}  (depth {result['depth']})")
+        print(f"  {result['path']}")
+
+    elif sub == "add":
         if not target:
             print("Usage: c3 sub add <folder> [--parent PATH] [--name NAME]")
             return
@@ -8026,16 +8129,19 @@ def cmd_sub(args):
         if not children:
             print("No sub-projects designated. Use `c3 sub add <folder>`.")
             return
-        fmt = "{:<22} {:<16} {:>6} {:>7}  {}"
-        print(fmt.format("NAME", "STATUS", "FACTS", "ALERTS", "REL PATH"))
-        print("-" * 76)
+        fmt = "{:<22} {:<16} {:<9} {:>6} {:>7}  {}"
+        print(fmt.format("NAME", "STATUS", "LINK", "FACTS", "ALERTS", "LOCATION"))
+        print("-" * 90)
         for c in children:
+            # An external child has no rel_path — show where it actually lives.
+            location = c.get("rel_path") or c.get("path", "")
             print(fmt.format(
                 (c.get("name") or "?")[:21],
                 c.get("status", "?"),
+                c.get("link_kind", "nested"),
                 c.get("facts_count", 0),
                 c.get("notification_count", 0),
-                c.get("rel_path", ""),
+                location,
             ))
         issues = sum(1 for c in children if c["status"] != "ok")
         line = f"\n{len(children)} sub-project(s)"
@@ -8075,7 +8181,8 @@ def cmd_sub(args):
             return
         result = sm.cascade(target,
                             include_parent=getattr(args, "include_parent", False),
-                            mcp=getattr(args, "mcp", False))
+                            mcp=getattr(args, "mcp", False),
+                            depth=depth)
         if as_json:
             print(json.dumps(result, indent=2))
             return
@@ -8096,7 +8203,8 @@ def cmd_sub(args):
             print("No sub-projects designated.")
             return
         for c in result["children"]:
-            print(f"  [{c['status']:<16}] {c.get('name') or '?':<22} {c.get('rel_path', '')}")
+            location = c.get("rel_path") or c.get("path", "")
+            print(f"  [{c['status']:<16}] {c.get('name') or '?':<22} {location}")
         for o in result["orphans"]:
             print(f"  [orphan_registry ] {o}")
         for f in result.get("fixed", []):

{code_context_control-2.95.0 → code_context_control-2.96.1}/cli/commands/parser.py

@@ -152,7 +152,7 @@ def build_parser(version: str, parse_cli_ide_arg):
     p_sub.add_argument(
         "sub_cmd",
         nargs="?",
-        choices=["add", "list", "remove", "run", "check"],
+        choices=["add", "link", "inspect", "list", "tree", "remove", "run", "check"],
         default="list",
         help="Sub-command (default: list)",
     )
@@ -160,7 +160,8 @@ def build_parser(version: str, parse_cli_ide_arg):
         "target",
         nargs="?",
         default=None,
-        help="Folder (add), sub-project name/path (remove), or operation update|reindex|health (run)",
+        help="Folder (add), path to an existing project (link|inspect), "
+             "sub-project name/path (remove), or operation update|reindex|health (run)",
     )
     p_sub.add_argument("--parent", default=".", help="Parent project path (default: current directory)")
     p_sub.add_argument("--name", default=None, help="Display name for the sub-project (add)")
@@ -173,6 +174,12 @@ def build_parser(version: str, parse_cli_ide_arg):
     p_sub.add_argument("--mcp", action="store_true", help="Also reinstall MCP config on update (run update)")
     p_sub.add_argument("--fix", action="store_true", help="Repair links from the parent config (check)")
     p_sub.add_argument("--prune", action="store_true", help="With --fix: drop entries whose folder is gone (check)")
+    p_sub.add_argument("--depth", default=None, type=int,
+                       help="Levels to descend (tree|run); default: the full hierarchy")
+    p_sub.add_argument("--init", action="store_true",
+                       help="Initialize the folder if it is not a C3 project yet (link)")
+    p_sub.add_argument("--no-detect", action="store_true",
+                       help="Skip the scan for unlinked nested projects (inspect)")
     p_sub.add_argument("--json", action="store_true", help="Emit JSON output")
 
     p_perms = subparsers.add_parser("permissions",

{code_context_control-2.95.0 → code_context_control-2.96.1}/cli/guide/tools.html

@@ -1394,10 +1394,14 @@ c3_jira(action=<span class="str">'comment'</span>, issue=<span class="str">'PROJ
               <tr><td class="param-name">scan</td><td>Discover</td><td class="param-desc">Registry + bounded filesystem scan for unregistered <code>.c3</code> projects nearby</td></tr>
               <tr><td class="param-name">info, register, unregister</td><td>Discover</td><td class="param-desc">Project details / add to / remove from the registry</td></tr>
               <tr><td class="param-name">search, read, compress, status, memory, impact, edits, validate, filter</td><td>Read</td><td class="param-desc">Proxy the matching c3_* tool against the target project</td></tr>
+              <tr><td class="param-name">subprojects, sub_tree, sub_inspect</td><td>Read</td><td class="param-desc">Direct children; the whole hierarchy; a read-only report on any path (what is there, who already claims it, what it claims, which nested projects under it are unlinked)</td></tr>
+              <tr><td class="param-name">sub_add, sub_link, sub_remove, sub_cascade</td><td>Write</td><td class="param-desc">Designate / link by path / unlink / cascade across the subtree — require <code>allow_write=true</code> (<code>sub_cascade</code> with <code>mode='health'</code> is a read)</td></tr>
               <tr><td class="param-name">edit, shell, memory(add/update/delete)</td><td>Write</td><td class="param-desc">Mutate the target project — require <code>allow_write=true</code></td></tr>
             </tbody>
           </table>
 
+          <p class="tool-desc"><strong>Sub-project hierarchy:</strong> <code>project</code> is the PARENT. A child need not live inside it — <code>sub_link</code> takes an absolute path anywhere on disk, including another drive — and hierarchies nest up to 8 levels. Nested children are excluded from the parent's index; externally linked ones were never in it. Linking is refused if it would make a project its own ancestor.</p>
+
           <h4>Examples</h4>
           <pre><code><span class="com"># Which projects have C3 installed?</span>
 c3_project(action=<span class="str">'list'</span>)
@@ -1414,7 +1418,18 @@ c3_project(action=<span class="str">'memory'</span>, project=<span class="str">'
 c3_project(action=<span class="str">'edit'</span>, project=<span class="str">'Sentinel'</span>,
            file_path=<span class="str">'README.md'</span>,
            old_string=<span class="str">'v1'</span>, new_string=<span class="str">'v2'</span>,
-           allow_write=<span class="num">true</span>)</code></pre>
+           allow_write=<span class="num">true</span>)
+
+<span class="com"># What is at this path, and who already claims it? (read-only)</span>
+c3_project(action=<span class="str">'sub_inspect'</span>, project=<span class="str">'Code Context Control'</span>,
+           target=<span class="str">r'U:\1. Projects\Claude Code Companion (C3)\c3-mobile'</span>)
+
+<span class="com"># Link it — a sibling on disk, not nested, so containment cannot express it</span>
+c3_project(action=<span class="str">'sub_link'</span>, project=<span class="str">'Code Context Control'</span>,
+           target=<span class="str">r'U:\1. Projects\Claude Code Companion (C3)\c3-mobile'</span>,
+           allow_write=<span class="num">true</span>)
+
+c3_project(action=<span class="str">'sub_tree'</span>, project=<span class="str">'Code Context Control'</span>)   <span class="com"># every level</span></code></pre>
 
           <p class="tool-desc"><strong>Sub-action params:</strong> <code>search_action</code> (code/files/semantic/…), <code>mem_action</code> (recall/index/fetch/add/…), and <code>edits_action</code> (history/versions/stats) pick the operation for those verbs; <code>scan_roots</code> (comma-separated) overrides where <code>scan</code> looks.</p>
         </div>

{code_context_control-2.95.0 → code_context_control-2.96.1}/cli/guide/workflow.html

@@ -912,12 +912,29 @@ c3_session(action=<span class="str">'restore'</span>)</code></pre>
     <section class="section" id="subprojects">
       <div class="section-title"><span class="icon">🌳</span> Sub-projects</div>
 
-      <p>Since v2.44.0, a c3 project can link folders that physically live inside it as <strong>sub-projects</strong>. Each child gets its own full <code>.c3</code> (index, memory, config), the parent's index excludes the child's subtree, and the link is recorded in three places at once: the parent config's <code>subprojects[]</code> array, a back-link in the child's config, and the hub registry. Links are depth-1 — a child cannot have children of its own.</p>
+      <p>A c3 project can claim another one as a <strong>sub-project</strong>. Each child keeps its own full <code>.c3</code> (index, memory, config), and the link is recorded in three places at once: the parent config's <code>subprojects[]</code> array, a back-link in the child's config, and the hub registry.</p>
+
+      <p>Since v2.96.0 the child does <strong>not</strong> have to live inside the parent's folder, and hierarchies nest to <strong>8 levels</strong> — a sub-project can have sub-projects of its own. There are two link kinds, and C3 picks from the path you give it:</p>
+      <table class="table">
+        <thead><tr><th>Kind</th><th>Where the child lives</th><th>Effect on the parent's index</th></tr></thead>
+        <tbody>
+          <tr><td><code>nested</code></td><td>Inside the parent's folder</td><td>The child's subtree is excluded, so nothing is indexed twice</td></tr>
+          <tr><td><code>external</code></td><td>Anywhere — a sibling folder, another drive</td><td>None: the child was never inside the tree the parent scans</td></tr>
+        </tbody>
+      </table>
 
       <div class="callout callout-tip">
         <span class="callout-icon">💡</span>
         <div class="callout-body">
-          Use sub-projects for monorepos and nested apps: each child stays independently searchable with its own memory, while the parent can fan queries out across the whole family.
+          Use sub-projects for monorepos and nested apps, and for the case that has no folder to nest: two checkouts of one product sitting side by side. Each child stays independently searchable with its own memory, while the parent can fan queries out across the whole family.
+        </div>
+      </div>
+
+      <div class="callout callout-warning">
+        <span class="callout-icon">⚠️</span>
+        <div class="callout-body">
+          <strong>No cycles</strong>
+          Hierarchy is a strict tree: one parent per project. While a child had to live inside its parent, a loop was impossible by construction; now that it can live anywhere, every link is checked against the ancestor chain and refused if it would make a project its own ancestor.
         </div>
       </div>
 
@@ -925,21 +942,33 @@ c3_session(action=<span class="str">'restore'</span>)</code></pre>
       <table class="table">
         <thead><tr><th>Command</th><th>Effect</th></tr></thead>
         <tbody>
+          <tr>
+            <td><code>c3 sub link &lt;path&gt; [--name --init]</code></td>
+            <td>Link an existing C3 project as a child — anywhere on disk, including another drive. Refuses a folder that is not already a project unless you pass <code>--init</code>.</td>
+          </tr>
+          <tr>
+            <td><code>c3 sub inspect &lt;path&gt;</code></td>
+            <td>Read-only report on any path: is there a project there, what is in it, who already claims it, what it claims, and which nested projects underneath are not linked yet. Mutates nothing.</td>
+          </tr>
           <tr>
             <td><code>c3 sub add &lt;folder&gt; [--name --ide]</code></td>
-            <td>Link a folder inside the current project. Adopts an existing <code>.c3</code>, otherwise runs a full init. <code>--no-init</code> links without initializing; <code>--parent &lt;path&gt;</code> targets a different parent.</td>
+            <td>Designate a folder as a child, initializing it. Adopts an existing <code>.c3</code>, otherwise runs a full init. <code>--no-init</code> links without initializing; <code>--parent &lt;path&gt;</code> targets a different parent.</td>
           </tr>
           <tr>
             <td><code>c3 sub list</code></td>
-            <td>Tree of linked children with status (the default when no sub-command is given).</td>
+            <td>Direct children with status and link kind (the default when no sub-command is given).</td>
+          </tr>
+          <tr>
+            <td><code>c3 sub tree [--depth N]</code></td>
+            <td>The whole hierarchy, indented, with a subtree rollup. <code>--depth</code> stops the walk early.</td>
           </tr>
           <tr>
             <td><code>c3 sub remove &lt;ref&gt; [--clear]</code></td>
             <td>Unlink a child and promote it to a standalone top-level project (its <code>.c3</code> is kept). <code>--clear</code> also wipes <code>.c3</code>, uninstalls the MCP config and instruction docs, and deregisters it.</td>
           </tr>
           <tr>
-            <td><code>c3 sub run &lt;update|reindex|health&gt; [--include-parent]</code></td>
-            <td>Cascade an operation across every child. <code>--mcp</code> also reinstalls the MCP config during <code>update</code>.</td>
+            <td><code>c3 sub run &lt;update|reindex|health&gt; [--include-parent --depth N]</code></td>
+            <td>Cascade an operation across the whole subtree. <code>--mcp</code> also reinstalls the MCP config during <code>update</code>.</td>
           </tr>
           <tr>
             <td><code>c3 sub check [--fix --prune]</code></td>
@@ -954,8 +983,8 @@ c3_session(action=<span class="str">'restore'</span>)</code></pre>
         <thead><tr><th>Value</th><th>Meaning</th></tr></thead>
         <tbody>
           <tr><td><code>''</code></td><td>Current project only (default)</td></tr>
-          <tr><td><code>'all'</code></td><td>Fan out across the parent and all linked children</td></tr>
-          <tr><td><code>'&lt;child&gt;'</code></td><td>One specific sub-project by name</td></tr>
+          <tr><td><code>'all'</code></td><td>Fan out across the parent and every descendant, at any depth</td></tr>
+          <tr><td><code>'&lt;child&gt;'</code></td><td>One specific descendant by name</td></tr>
         </tbody>
       </table>
 
@@ -967,11 +996,12 @@ c3_memory(action=<span class="str">'recall'</span>, query=<span class="str">'pay
       <h4>Hub UI management (v2.57.0)</h4>
       <p>Everything the CLI does — plus the operations that need multi-step safety — is available in the Hub:</p>
       <ul>
+        <li><strong>"Link project by path…"</strong> (v2.96.0) — kebab menu on any card, at any depth. Browse anywhere or paste a path; C3 inspects it before anything happens and shows you what you are about to claim — the project's name and version, whether the hub already knows it, how much is in it, who already claims it, and what sub-projects it would bring with it. One confirm registers and links an unregistered project. Unlinked nested projects it finds are offered as suggestions, never applied.</li>
         <li><strong>Designate</strong> — kebab menu → "Designate sub-project…" on any project card, or from the drill-in <strong>Sub-projects</strong> tab. A folder picker fenced to the parent's subtree validates the choice, shows adopt-vs-initialize expectations up front, and offers an instruction-docs/IDE picker (<code>auto | claude | vscode | cursor | codex | antigravity</code>).</li>
-        <li><strong>"Make sub-project of…"</strong> — the reverse move: a top-level card whose folder physically sits inside a registered parent can link itself under it (containment is mandatory).</li>
+        <li><strong>"Make sub-project of…"</strong> — the reverse move: pick any registered project to sit under. The only projects excluded are this one and its own descendants.</li>
         <li><strong>Sub-projects drill tab</strong> — per-child rows with inline <em>Validate</em> and <em>Promote</em>; inline <em>Reconcile</em> with per-issue detail and planned repair actions; a <em>Cascade</em> launcher with operation picker, include-parent toggle, affected-children preview, live progress, and Cancel.</li>
         <li><strong>Link health, passively</strong> — parents show a red "N link issues" badge and children a status badge (<code>ok · backlink_broken · unregistered · missing_folder · missing_c3 · orphan</code>), computed from config + filesystem on every listing — no manual reconcile needed to spot trouble.</li>
-        <li><strong>"Change parent…"</strong> — a staged wizard, because folders must physically move: ready-now targets relink immediately; otherwise unlink → move the folder yourself → validate → relink, with a per-step checklist and Undo before the move.</li>
+        <li><strong>"Change parent…"</strong> — unlink → validate → relink, with a per-step checklist. Since a child can be addressed by absolute path, re-parenting is a configuration change and no files move.</li>
         <li><strong>"De-initialize…"</strong> — clear-mode removal behind a typed-name confirmation: deletes <code>.c3</code>, uninstalls the MCP config, removes instruction docs, deregisters. Your code is untouched.</li>
         <li><strong>Federation toggles</strong> — the config editor's Sub-projects section on parent projects: memory roll-up, search fan-out for <code>scope='all'</code>, and max children per query, persisted under <code>hybrid.subprojects</code>.</li>
         <li><strong>Ctrl-K scope chips</strong> — global search can target All, Top-level only, or one parent + its children; child results carry a "parent › child" breadcrumb.</li>

{code_context_control-2.95.0 → code_context_control-2.96.1}/cli/hub_server.py

@@ -537,7 +537,7 @@ def _compute_subproject_links(projects):
         config_paths = set()
         for entry in entries:
             try:
-                key = _norm_realpath(mgr._abs_child(entry.get("rel_path", "")))
+                key = _norm_realpath(mgr._abs_child(entry))
                 status = mgr._entry_status(entry, registry)
             except Exception:
                 continue
@@ -609,10 +609,26 @@ def api_projects_list():
         from services.task_store import open_task_count
         projects = _pm().list_projects()
         parent_paths = {os.path.normcase(p["parent_path"]) for p in projects if p.get("parent_path")}
+        # Depth from the registry alone — no disk reads. Bounded by the number
+        # of projects and a visited-set, so a corrupt cycle cannot hang the poll.
+        by_path = {os.path.normcase(p.get("path", "")): p for p in projects}
+
+        def _depth(row):
+            n, seen, cursor = 0, set(), row
+            while cursor and cursor.get("parent_path"):
+                key = os.path.normcase(cursor["parent_path"])
+                if key in seen or key not in by_path:
+                    break
+                seen.add(key)
+                cursor = by_path[key]
+                n += 1
+            return n
+
         for p in projects:
             p["notification_count"] = _notification_count(p.get("path", ""))
             p["is_parent"] = os.path.normcase(p.get("path", "")) in parent_paths
             p["open_task_count"] = open_task_count(p.get("path", ""))
+            p["depth"] = _depth(p)
         _annotate_subproject_links(projects)
         return jsonify(projects)
     except Exception as e:
@@ -1438,18 +1454,87 @@ def _parse_json_tail(output: str):
 
 @app.route("/api/projects/subprojects", methods=["GET"])
 def api_subprojects_tree():
-    """Parent + children + rollup. Query: ?parent=<path>"""
+    """Parent + descendants + rollup. Query: ?parent=<path>&depth=<n>
+
+    ``depth`` defaults to the full hierarchy; pass 1 for the direct-children
+    shape the drill-in panel used before 2.96.
+    """
     parent = (request.args.get("parent") or "").strip()
     if not parent:
         return jsonify({"error": "parent is required"}), 400
     try:
-        return jsonify(_sub_manager(parent).tree())
+        from services.subprojects import MAX_DEPTH
+        depth = int(request.args.get("depth") or MAX_DEPTH)
+    except (TypeError, ValueError):
+        return jsonify({"error": "depth must be an integer"}), 400
+    try:
+        return jsonify(_sub_manager(parent).tree(depth=depth))
     except ValueError as e:
         return jsonify({"error": str(e)}), 404
     except Exception as e:
         return jsonify({"error": str(e)}), 500
 
 
+@app.route("/api/projects/subprojects/inspect", methods=["POST"])
+def api_subprojects_inspect():
+    """Read-only report on any path. Body: {path, detect?}
+
+    Answers "is there a C3 project here, what is in it, who already claims it,
+    what does it claim, and what nested projects under it are unlinked?" —
+    without registering, linking, or initializing anything. This is what the
+    Hub calls before offering to link, so it must stay side-effect free.
+    """
+    data = request.get_json(force=True) or {}
+    path = (data.get("path") or "").strip()
+    if not path:
+        return jsonify({"error": "path is required"}), 400
+    try:
+        from services.subprojects import inspect_path
+        return jsonify(inspect_path(path, detect=bool(data.get("detect", True))))
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+@app.route("/api/projects/hierarchy", methods=["GET"])
+def api_projects_hierarchy():
+    """The whole forest: every root project with its descendants. Query: ?depth=<n>
+
+    Roots are registered projects with no parent back-link. A project whose
+    parent is not itself registered still surfaces as a root, so nothing can
+    fall out of the listing because of a broken link.
+    """
+    try:
+        from services.subprojects import MAX_DEPTH, SubprojectManager, parent_link
+        depth = int(request.args.get("depth") or MAX_DEPTH)
+    except (TypeError, ValueError):
+        return jsonify({"error": "depth must be an integer"}), 400
+    try:
+        projects = ProjectManager()._read_projects()
+        known = {os.path.normcase(p.get("path", "")) for p in projects}
+        roots, claimed = [], set()
+        for p in projects:
+            path = p.get("path", "")
+            if not path:
+                continue
+            link = parent_link(path)
+            parent = link.get("path") or p.get("parent_path")
+            if parent and os.path.normcase(str(Path(parent).resolve())) in known:
+                claimed.add(os.path.normcase(path))
+                continue
+            roots.append(p)
+        out = []
+        for p in roots:
+            try:
+                out.append(SubprojectManager(p["path"]).tree(depth=depth))
+            except Exception as e:  # one bad root must not blank the forest
+                out.append({"parent": {"name": p.get("name"), "path": p["path"]},
+                            "children": [], "rollup": {}, "error": str(e)})
+        return jsonify({"roots": out, "root_count": len(out),
+                        "linked_count": len(claimed), "depth": depth})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
 @app.route("/api/projects/subprojects/validate", methods=["POST"])
 def api_subprojects_validate():
     """Pre-flight a designation. Body: {parent, folder}"""
@@ -1493,6 +1578,41 @@ def api_subprojects_add():
     return jsonify(body), (201 if ok else 500)
 
 
+@app.route("/api/projects/subprojects/link", methods=["POST"])
+def api_subprojects_link():
+    """Link an existing project by path. Body: {parent, folder, name?, ide?, init?}
+
+    The register-and-link one-shot behind the Hub's "Register + link" button.
+    ``folder`` may be anywhere on disk — inside the parent, a sibling, another
+    drive. Unlike ``/add`` this refuses a folder that is not already a C3
+    project unless ``init`` is set, so "link" never silently creates one.
+
+    Shells out like /add and /remove, so errors land at result.error and the
+    frontend's apiErr() keeps reading them.
+    """
+    data = request.get_json(force=True) or {}
+    parent = (data.get("parent") or "").strip()
+    folder = (data.get("folder") or "").strip()
+    if not parent or not folder:
+        return jsonify({"error": "parent and folder are required"}), 400
+    args = ["sub", "link", folder, "--parent", parent, "--json"]
+    name = (data.get("name") or "").strip()
+    if name:
+        args += ["--name", name]
+    ide = (data.get("ide") or "").strip()
+    if ide and ide != "unknown":
+        args += ["--ide", ide]
+    if data.get("init"):
+        args.append("--init")
+    res = _run_c3(args, timeout=300)
+    payload = _parse_json_tail(res.get("output", ""))
+    ok = res.get("success") and bool((payload or {}).get("added"))
+    if ok:
+        _invalidate_subproject_links()
+    body = {"success": ok, "result": payload, "output": res.get("output", "")}
+    return jsonify(body), (201 if ok else 500)
+
+
 @app.route("/api/projects/subprojects/remove", methods=["POST"])
 def api_subprojects_remove():
     """Unlink (Promote) or clear a sub-project. Body: {parent, ref, mode: unlink|clear}"""

{code_context_control-2.95.0 → code_context_control-2.96.1}/cli/hub_ui/components/drill_panel.js

@@ -111,9 +111,11 @@ function DrillNeedsInit({ project, onReady }) {
 }
 
 function DrillPanel({ project, tab, setTab, onClose, onChanged, onOpenModal, projects }) {
-  // Children can't have children (depth-1) — hide the Sub-projects tab for them.
+  // A sub-project may have sub-projects of its own, so the Sub-projects tab
+  // stays available at every level. isChild now only drives the "under
+  // <parent>" chip below.
   const isChild = !!project.parent_path;
-  const tabs = DRILL_PANEL_TABS.filter(([id]) => id !== 'subprojects' || !isChild);
+  const tabs = DRILL_PANEL_TABS;
   // "under <parent>" chip: friendly name from the loaded project list when
   // available (optional prop), else the last path segment.
   const parentName = (() => {