code-context-control 2.56.1__py3-none-any.whl → 2.57.0__py3-none-any.whl

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.56.1"
+__version__ = "2.57.0"
 
 
 def _command_deps() -> CommandDeps:

cli/guide/workflow.html

@@ -249,6 +249,7 @@
       <a href="#plan-mode" class="sidebar-link"><span class="icon">📐</span> Plan Mode</a>
       <a href="#session-restart" class="sidebar-link"><span class="icon">🔄</span> Session Restart</a>
       <a href="#terse-skill" class="sidebar-link"><span class="icon">⚡</span> /terse Skill</a>
+      <a href="#subprojects" class="sidebar-link"><span class="icon">🌳</span> Sub-projects</a>
       <a href="#native-fallback" class="sidebar-link"><span class="icon">⚠️</span> Native Fallback</a>
     </div>
   </aside>
@@ -355,6 +356,12 @@
             <td><code>c3_project(action='list')</code></td>
             <td>v2.31.0 — discover and operate on OTHER c3-installed projects; reads run free, writes need <code>allow_write=true</code>. <a href="tools.html#c3_project">Tool card →</a></td>
           </tr>
+          <tr>
+            <td><span class="badge badge-purple">+</span></td>
+            <td><strong>Sub-projects</strong></td>
+            <td><code>c3 sub add &lt;folder&gt;</code></td>
+            <td>v2.44.0 — link child projects living inside a parent; federated search/memory + Hub management. <a href="#subprojects">Section →</a></td>
+          </tr>
         </tbody>
       </table>
     </section>
@@ -897,6 +904,86 @@ c3_session(action=<span class="str">'restore'</span>)</code></pre>
 
     <hr class="divider">
 
+    <!-- Sub-projects -->
+    <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>
+
+      <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.
+        </div>
+      </div>
+
+      <h4>CLI — <code>c3 sub</code></h4>
+      <table class="table">
+        <thead><tr><th>Command</th><th>Effect</th></tr></thead>
+        <tbody>
+          <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>
+          </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>
+          </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>
+          </tr>
+          <tr>
+            <td><code>c3 sub check [--fix --prune]</code></td>
+            <td>Reconcile the three-way links. <code>--fix</code> repairs from the parent config; adding <code>--prune</code> drops entries whose folder is gone.</td>
+          </tr>
+        </tbody>
+      </table>
+
+      <h4>Agent surface — the <code>scope</code> parameter</h4>
+      <p><code>c3_search</code> and <code>c3_memory</code> accept a <code>scope</code> parameter on parent projects:</p>
+      <table class="table">
+        <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>
+        </tbody>
+      </table>
+
+      <pre><code>c3_search(query=<span class="str">'auth middleware'</span>, scope=<span class="str">'all'</span>)
+c3_memory(action=<span class="str">'recall'</span>, query=<span class="str">'payment gotchas'</span>, scope=<span class="str">'billing-service'</span>)</code></pre>
+
+      <p>With <code>hybrid.subprojects.memory_rollup</code> enabled, a parent-side recall also unions in the children's facts automatically.</p>
+
+      <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>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>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>"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>
+      </ul>
+
+      <div class="callout callout-warning">
+        <span class="callout-icon">⚠️</span>
+        <div class="callout-body">
+          <strong>Managed keys</strong>
+          The raw <code>subprojects</code> / <code>parent</code> config keys render read-only in the Hub config editor by design — hierarchy changes only go through the dedicated actions above (CLI or Hub), never by hand-editing the link records.
+        </div>
+      </div>
+    </section>
+
+    <hr class="divider">
+
     <!-- Native fallback -->
     <section class="section" id="native-fallback">
       <div class="section-title"><span class="icon">⚠️</span> When Native Tools Are Permitted</div>

cli/hub_server.py

@@ -333,6 +333,7 @@ _HUB_JS_FILES = [
     "hub_ui/components/session_drawer.js",
     "hub_ui/components/drill_panel.js",
     "hub_ui/components/drill_views.js",
+    "hub_ui/components/drill_subprojects.js",
     "hub_ui/components/drill_health.js",
     "hub_ui/components/drill_tasks.js",
     "hub_ui/components/drill_artifacts.js",
@@ -477,6 +478,129 @@ def _notification_count(project_path: str) -> int:
     return count
 
 
+_sub_links_cache = {"fp": None, "ts": 0.0, "data": None, "computing": False}
+_sub_links_lock = threading.Lock()
+_SUB_LINKS_TTL = 15.0
+
+
+def _invalidate_subproject_links():
+    """Drop the cached link-health snapshot (call after any hierarchy mutation)."""
+    with _sub_links_lock:
+        _sub_links_cache.update({"fp": None, "ts": 0.0, "data": None})
+
+
+def _sub_federation_errors(sub):
+    """Schema check for the hybrid.subprojects federation dict (config PUT)."""
+    allowed = {"memory_rollup", "search_fanout", "max_children_per_query"}
+    unknown = sorted(set(sub) - allowed)
+    if unknown:
+        return f"unknown keys {unknown}"
+    for k in ("memory_rollup", "search_fanout"):
+        if k in sub and not isinstance(sub[k], bool):
+            return f"'{k}' must be a boolean"
+    v = sub.get("max_children_per_query")
+    if v is not None and (isinstance(v, bool) or not isinstance(v, int) or not 1 <= v <= 256):
+        return "'max_children_per_query' must be an integer between 1 and 256"
+    return ""
+
+
+def _norm_realpath(s):
+    """resolve()+normcase, matching services.subprojects._norm — plain
+    normcase alone would flag symlinked/8.3/trailing-slash registry rows
+    as false orphans that Reconcile then denies."""
+    try:
+        return os.path.normcase(str(Path(s).resolve()))
+    except Exception:
+        return os.path.normcase(str(s or ""))
+
+
+def _compute_subproject_links(projects):
+    """Statuses only — deliberately NOT SubprojectManager.list(), which
+    also parses facts.json and notifications.jsonl per child; those counts
+    were computed and thrown away on every poll recompute."""
+    from services.subprojects import SubprojectManager, get_subprojects
+    parents_out, children_out = {}, {}
+    registry = None
+    for parent in projects:
+        if not (parent.get("is_parent") or parent.get("subproject_count")):
+            continue
+        try:
+            mgr = SubprojectManager(parent.get("path", ""))
+            entries = get_subprojects(mgr.parent_path)
+            if registry is None:
+                registry = mgr.pm._read_projects()
+        except Exception:
+            continue
+        issues = 0
+        config_paths = set()
+        for entry in entries:
+            try:
+                key = _norm_realpath(mgr._abs_child(entry.get("rel_path", "")))
+                status = mgr._entry_status(entry, registry)
+            except Exception:
+                continue
+            config_paths.add(key)
+            if status != "ok":
+                issues += 1
+            children_out[key] = status
+        parent_key = _norm_realpath(parent.get("path", ""))
+        for row in projects:
+            rp = row.get("parent_path")
+            if (rp and _norm_realpath(rp) == parent_key
+                    and _norm_realpath(row.get("path", "")) not in config_paths):
+                issues += 1
+                children_out[_norm_realpath(row.get("path", ""))] = "orphan"
+        if issues:
+            parents_out[parent_key] = issues
+    return {"parents": parents_out, "children": children_out}
+
+
+def _annotate_subproject_links(projects):
+    """Per-parent link-health rollup + per-child link_status for the cards.
+
+    SubprojectManager.list() is config + filesystem + raw-registry reads
+    only (no child runtimes, no port probing). Registry orphans (rows
+    claiming a parent that has no matching config entry) count as issues
+    too — same rule as reconcile. The snapshot is cached _SUB_LINKS_TTL
+    seconds and computed single-flight, so overlapping UI polls never
+    stack behind a slow disk (e.g. a disconnected network drive); the
+    fingerprint ties the cache to the registry rows, and mutating
+    sub-project endpoints call _invalidate_subproject_links().
+    """
+    fp = tuple(sorted((os.path.normcase(p.get("path", "")),
+                       os.path.normcase(p.get("parent_path") or ""))
+                      for p in projects))
+    now = time.time()
+    do_compute = False
+    with _sub_links_lock:
+        snap = _sub_links_cache["data"]
+        fresh = (snap is not None and _sub_links_cache["fp"] == fp
+                 and now - _sub_links_cache["ts"] < _SUB_LINKS_TTL)
+        if not fresh:
+            if _sub_links_cache["computing"]:
+                if _sub_links_cache["fp"] != fp:
+                    snap = None          # stale snapshot of a different registry — skip
+            else:
+                _sub_links_cache["computing"] = True
+                do_compute = True
+    if do_compute:
+        try:
+            snap = _compute_subproject_links(projects)
+            with _sub_links_lock:
+                _sub_links_cache.update({"fp": fp, "ts": time.time(), "data": snap})
+        finally:
+            with _sub_links_lock:
+                _sub_links_cache["computing"] = False
+    if not snap:
+        return
+    for p in projects:
+        key = _norm_realpath(p.get("path", ""))
+        if key in snap["parents"]:
+            p["subproject_issues"] = snap["parents"][key]
+        if key in snap["children"]:
+            p["link_status"] = snap["children"][key]
+
+
 @app.route("/api/projects", methods=["GET"])
 def api_projects_list():
     try:
@@ -487,6 +611,7 @@ def api_projects_list():
             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", ""))
+        _annotate_subproject_links(projects)
         return jsonify(projects)
     except Exception as e:
         return jsonify({"error": str(e)}), 500
@@ -519,6 +644,8 @@ def api_projects_remove():
         orphans = [p.get("path") for p in _pm().list_projects()
                    if p.get("parent_path") and os.path.normcase(p["parent_path"]) == resolved]
         result = {"removed": _pm().remove_project(path)}
+        if result["removed"]:
+            _invalidate_subproject_links()
         if result["removed"] and orphans:
             result["orphaned_children"] = orphans
         return jsonify(result)
@@ -1226,6 +1353,8 @@ def api_subprojects_add():
     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)
 
@@ -1247,6 +1376,8 @@ def api_subprojects_remove():
     res = _run_c3(args, timeout=300)
     payload = _parse_json_tail(res.get("output", ""))
     ok = res.get("success") and bool((payload or {}).get("removed"))
+    if ok:
+        _invalidate_subproject_links()
     body = {"success": ok, "result": payload, "output": res.get("output", "")}
     return jsonify(body), (200 if ok else 500)
 
@@ -1259,8 +1390,11 @@ def api_subprojects_reconcile():
     if not parent:
         return jsonify({"error": "parent is required"}), 400
     try:
-        return jsonify(_sub_manager(parent).reconcile(
-            fix=bool(data.get("fix")), prune=bool(data.get("prune"))))
+        result = _sub_manager(parent).reconcile(
+            fix=bool(data.get("fix")), prune=bool(data.get("prune")))
+        if data.get("fix"):
+            _invalidate_subproject_links()
+        return jsonify(result)
     except ValueError as e:
         return jsonify({"error": str(e)}), 404
     except Exception as e:
@@ -1321,6 +1455,7 @@ def _sub_cascade_worker(op: str, targets: list):
         _sub_cascade_state["running"] = False
         _sub_cascade_state["done"] = True
         _sub_cascade_state["current"] = None
+    _invalidate_subproject_links()
 
 
 @app.route("/api/projects/subprojects/cascade", methods=["POST"])
@@ -1339,11 +1474,20 @@ def api_subprojects_cascade():
         return jsonify({"error": "op must be update|reindex|health"}), 400
     try:
         sm = _sub_manager(parent)
-        targets = sm.list()
+        listed = sm.list()
+        # Skipped children (missing folder; missing .c3 unless the op can
+        # create it) are excluded up front so total and the success
+        # denominator reflect real work — previously they inflated total
+        # and reported as failures.
+        skipped = [t for t in listed
+                   if t.get("status") == "missing_folder"
+                   or (t.get("status") == "missing_c3" and op != "update")]
+        targets = [t for t in listed if t not in skipped]
         if data.get("include_parent"):
             targets.append({"name": "(parent)", "path": sm.parent_path, "status": "ok"})
         if not targets:
-            return jsonify({"error": "No sub-projects designated"}), 400
+            return jsonify({"error": "No cascade-eligible sub-projects"
+                            + (f" ({len(skipped)} skipped)" if skipped else "")}), 400
         with _sub_cascade_lock:
             _sub_cascade_state = {
                 "running": True, "cancelled": False, "results": [],
@@ -1352,7 +1496,8 @@ def api_subprojects_cascade():
             }
         t = threading.Thread(target=_sub_cascade_worker, args=(op, targets), daemon=True)
         t.start()
-        return jsonify({"started": True, "total": len(targets), "op": op})
+        return jsonify({"started": True, "total": len(targets), "op": op,
+                        "skipped": len(skipped)})
     except ValueError as e:
         return jsonify({"error": str(e)}), 404
     except Exception as e:
@@ -1643,6 +1788,18 @@ def api_projects_config_put():
         return jsonify({"error": "values must be an object"}), 400
     for refused in _CONFIG_REFUSED_KEYS:
         if refused in values:
+            # 'subprojects' under the hybrid section is the federation
+            # settings DICT (memory_rollup / search_fanout / …), not the
+            # top-level child-links ARRAY — the array stays refused (and is
+            # unreachable through the section whitelist anyway). Schema-check
+            # the dict: exactly these keys, exactly these types — the generic
+            # deep-merge below would happily persist anything.
+            if (section == "hybrid" and refused == "subprojects"
+                    and isinstance(values["subprojects"], dict)):
+                bad = _sub_federation_errors(values["subprojects"])
+                if bad:
+                    return jsonify({"error": f"hybrid.subprojects: {bad}"}), 400
+                continue
             return jsonify({"error": f"'{refused}' cannot be edited here"}), 400
     try:
         resolved = _resolve_project_path(path)

cli/hub_ui/app.js

@@ -128,7 +128,7 @@ function App() {
       {drawerProject &&
         <SessionDrawer project={drawerProject} onClose={() => setDrawerProject(null)} />}
       {drill &&
-        <DrillPanel project={drill} tab={drillTab} setTab={setDrillTab}
+        <DrillPanel project={drill} tab={drillTab} setTab={setDrillTab} projects={projects}
           onClose={() => setDrill(null)} onChanged={loadProjects} onOpenModal={openModal} />}
       <GlobalSearch open={searchOpen} onClose={() => setSearchOpen(false)} projects={projects}
         onOpenProject={(p, tab) => { setSearchOpen(false); openDrill(p, tab || 'overview'); }} />

cli/hub_ui/components/config_editor.js

@@ -6,6 +6,15 @@
 const CFG_ED_SECTIONS = ['hybrid', 'agents', 'delegate', 'proxy', 'mcp', 'meta', 'memory_llm', 'bitbucket'];
 const CFG_ED_READONLY = ['bitbucket'];
 const CFG_ED_REFUSED = ['version', 'project_path', 'permission_tier', 'subprojects', 'parent', 'api_key'];
+// Refused keys worth surfacing read-only when present, rather than hiding —
+// still never editable here (server refuses the write regardless).
+const CFG_ED_MANAGED = ['subprojects', 'parent'];
+const CFG_ED_MANAGED_HINT = 'Managed via sub-project actions — use the project card menu or drill-in panel.';
+// hybrid.subprojects federation settings get a friendly "Sub-projects"
+// section on parent projects. The hub API accepts dict-valued 'subprojects'
+// under section=hybrid (schema-checked server-side); the read-only fallback
+// below only engages if this flag is ever flipped off again.
+const CFG_ED_SUBPROJECTS_WRITABLE = true;
 
 function ConfigEditor({ project }) {
   const [section, setSection] = useState('hybrid');
@@ -36,11 +45,43 @@ function ConfigEditor({ project }) {
   };
   useEffect(() => { setCfg(null); load(); }, [project.path, section]);
 
+  // ── Sub-projects (hybrid.subprojects): friendly federation controls ─────
+  // Shown for parent projects on the hybrid section. Edits nest under one
+  // 'subprojects' key holding only the changed sub-keys, so the server's
+  // deep-merge preserves untouched siblings (e.g. parent_memory_visible).
+  const isParent = !!project.is_parent || (project.subproject_count || 0) > 0;
+  const showSubprojects = section === 'hybrid' && !!cfg
+    && (isParent || cfg.subprojects !== undefined);
+  const subCfg = (cfg && cfg.subprojects && typeof cfg.subprojects === 'object') ? cfg.subprojects : {};
+  const subDefs = (defs.subprojects && typeof defs.subprojects === 'object') ? defs.subprojects : {};
+  const subEdits = (edits.subprojects && typeof edits.subprojects === 'object') ? edits.subprojects : {};
+  const subVal = (k) => Object.prototype.hasOwnProperty.call(subEdits, k) ? subEdits[k]
+    : (subCfg[k] !== undefined ? subCfg[k] : subDefs[k]);
+  const subEdited = (k) => Object.prototype.hasOwnProperty.call(subEdits, k);
+  const subDot = (k) => subEdited(k)
+    ? <span style={{ width: 6, height: 6, borderRadius: '50%', background: T.accent, display: 'inline-block', flexShrink: 0 }} />
+    : null;
+  const setSubEdit = (k, v) => {
+    if (!CFG_ED_SUBPROJECTS_WRITABLE) return;
+    setEdits(e => {
+      const cur = Object.assign({}, (e.subprojects && typeof e.subprojects === 'object') ? e.subprojects : {});
+      cur[k] = v;
+      return Object.assign({}, e, { subprojects: cur });
+    });
+  };
+
   const keys = [];
+  const managedKeys = [];
   if (cfg) {
-    Object.keys(defs).forEach(k => { if (CFG_ED_REFUSED.indexOf(k) < 0) keys.push(k); });
+    Object.keys(defs).forEach(k => {
+      if (CFG_ED_REFUSED.indexOf(k) < 0) keys.push(k);
+      else if (CFG_ED_MANAGED.indexOf(k) >= 0 && managedKeys.indexOf(k) < 0
+        && !(k === 'subprojects' && showSubprojects)) managedKeys.push(k);
+    });
     Object.keys(cfg).forEach(k => {
-      if (CFG_ED_REFUSED.indexOf(k) < 0 && keys.indexOf(k) < 0) keys.push(k);
+      if (CFG_ED_REFUSED.indexOf(k) < 0) { if (keys.indexOf(k) < 0) keys.push(k); }
+      else if (CFG_ED_MANAGED.indexOf(k) >= 0 && managedKeys.indexOf(k) < 0
+        && !(k === 'subprojects' && showSubprojects)) managedKeys.push(k);
     });
   }
   const currentVal = (k) => Object.prototype.hasOwnProperty.call(edits, k) ? edits[k]
@@ -66,6 +107,14 @@ function ConfigEditor({ project }) {
           v = Number(v);
           if (!isFinite(v)) throw new Error(`'${k}' must be a number`);
         }
+        if (k === 'subprojects' && v && typeof v === 'object'
+          && Object.prototype.hasOwnProperty.call(v, 'max_children_per_query')) {
+          const n = Number(v.max_children_per_query);
+          if (!isFinite(n) || n < 1 || Math.floor(n) !== n) {
+            throw new Error("'max_children_per_query' must be a positive integer");
+          }
+          v = Object.assign({}, v, { max_children_per_query: n });
+        }
         values[k] = v;
       });
       const d = await api.put('/api/projects/config', { path: project.path, section, values });
@@ -83,6 +132,13 @@ function ConfigEditor({ project }) {
     Object.keys(defs).forEach(k => {
       if (CFG_ED_REFUSED.indexOf(k) < 0) next[k] = JSON.parse(JSON.stringify(defs[k] === undefined ? null : defs[k]));
     });
+    if (showSubprojects && CFG_ED_SUBPROJECTS_WRITABLE) {
+      next.subprojects = {
+        memory_rollup: subDefs.memory_rollup !== false,
+        search_fanout: subDefs.search_fanout !== false,
+        max_children_per_query: subDefs.max_children_per_query !== undefined ? subDefs.max_children_per_query : 8,
+      };
+    }
     setEdits(next);
     setJsonText({}); setJsonBad({});
     notify(`Prefilled ${section} defaults — review, then Save section`, 'warn');
@@ -91,6 +147,18 @@ function ConfigEditor({ project }) {
   const dirty = Object.keys(edits).length > 0;
   const invalid = Object.keys(jsonBad).some(k => jsonBad[k]);
 
+  const renderManagedField = (k) => {
+    const val = cfg && cfg[k] !== undefined ? cfg[k] : defs[k];
+    const text = (val !== null && typeof val === 'object')
+      ? JSON.stringify(val) : String(val === undefined ? '' : val);
+    return (
+      <div key={k} style={{ display: 'flex', gap: 12, alignItems: 'flex-start', padding: '6px 0', opacity: 0.55 }}>
+        <span className="mono" style={{ fontSize: 11, color: T.textDim, width: 200, flexShrink: 0, overflowWrap: 'anywhere' }}>{k}</span>
+        <span className="mono" style={{ fontSize: 11, color: T.textDim, flex: 1, overflowWrap: 'anywhere' }}>{text}</span>
+      </div>
+    );
+  };
+
   const renderField = (k) => {
     const kind = kindOf(k);
     const val = currentVal(k);
@@ -215,6 +283,62 @@ function ConfigEditor({ project }) {
           <div style={{ display: 'flex', flexDirection: 'column' }}>
             {keys.map(renderField)}
           </div>
+          {showSubprojects && (
+            <div style={{ marginTop: 14, paddingTop: 14, borderTop: `1px solid ${T.border}` }}>
+              <div style={{ fontSize: 12, fontWeight: 700, color: T.text }}>Sub-projects</div>
+              <div style={{ fontSize: 11, color: T.textDim, margin: '2px 0 4px' }}>
+                How this parent federates with its linked children (<span className="mono">hybrid.subprojects</span>).
+              </div>
+              {!CFG_ED_SUBPROJECTS_WRITABLE && (
+                <div style={{ fontSize: 11, color: T.textMuted, marginBottom: 4 }}>
+                  Read-only for now — the hub API refuses <span className="mono">subprojects</span> config writes.
+                  Edit <span className="mono">.c3/config.json</span> directly to change these.
+                </div>
+              )}
+              <div style={CFG_ED_SUBPROJECTS_WRITABLE ? undefined : { opacity: 0.55, pointerEvents: 'none' }}>
+                <div style={{ display: 'flex', alignItems: 'center', gap: 8 }}>
+                  <div style={{ flex: 1 }}>
+                    {renderBoolToggle('Parent memory recall includes child facts', !!subVal('memory_rollup'),
+                      () => setSubEdit('memory_rollup', !subVal('memory_rollup')),
+                      `memory_rollup — default: ${subDefs.memory_rollup === false ? 'off' : 'on'}`)}
+                  </div>
+                  {subDot('memory_rollup')}
+                </div>
+                <div style={{ display: 'flex', alignItems: 'center', gap: 8 }}>
+                  <div style={{ flex: 1 }}>
+                    {renderBoolToggle("Search scope 'all' fans out to children", !!subVal('search_fanout'),
+                      () => setSubEdit('search_fanout', !subVal('search_fanout')),
+                      `search_fanout — default: ${subDefs.search_fanout === false ? 'off' : 'on'}`)}
+                  </div>
+                  {subDot('search_fanout')}
+                </div>
+                <label style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', gap: 12, padding: '8px 0' }}>
+                  <span style={{ display: 'flex', flexDirection: 'column', gap: 3, minWidth: 0 }}>
+                    <span style={{ display: 'flex', alignItems: 'center', gap: 8 }}>
+                      <span style={{ color: T.textMuted, fontSize: 12 }}>Max children per query</span>
+                      {subDot('max_children_per_query')}
+                    </span>
+                    <span style={{ color: T.textDim, fontSize: 11 }}>
+                      max_children_per_query — cap per federated call, default: {subDefs.max_children_per_query !== undefined ? subDefs.max_children_per_query : 8}
+                    </span>
+                  </span>
+                  <input type="number" min={1} step={1} disabled={!CFG_ED_SUBPROJECTS_WRITABLE}
+                    value={subVal('max_children_per_query') == null ? '' : String(subVal('max_children_per_query'))}
+                    onChange={ev => setSubEdit('max_children_per_query', ev.target.value)}
+                    className="mono"
+                    style={drillFieldStyle({ width: 110, textAlign: 'right', fontSize: 11 })} />
+                </label>
+              </div>
+            </div>
+          )}
+          {managedKeys.length > 0 && (
+            <div style={{ marginTop: 14, paddingTop: 14, borderTop: `1px solid ${T.border}` }}>
+              <div style={{ fontSize: 11, color: T.textDim, marginBottom: 8 }}>{CFG_ED_MANAGED_HINT}</div>
+              <div style={{ display: 'flex', flexDirection: 'column' }}>
+                {managedKeys.map(renderManagedField)}
+              </div>
+            </div>
+          )}
           {!readOnly && (
             <div style={{
               display: 'flex', alignItems: 'center', gap: 10, marginTop: 20,

cli/hub_ui/components/drill_panel.js

@@ -5,6 +5,7 @@
 
 const DRILL_PANEL_TABS = [
   ['overview', 'Overview'],
+  ['subprojects', 'Sub-projects'],
   ['tasks', 'Tasks'],
   ['artifacts', 'Artifacts'],
   ['memory', 'Memory'],
@@ -106,9 +107,24 @@ function DrillNeedsInit({ project, onReady }) {
   );
 }
 
-function DrillPanel({ project, tab, setTab, onClose, onChanged, onOpenModal }) {
+function DrillPanel({ project, tab, setTab, onClose, onChanged, onOpenModal, projects }) {
+  // Children can't have children (depth-1) — hide the Sub-projects tab for them.
+  const isChild = !!project.parent_path;
+  const tabs = DRILL_PANEL_TABS.filter(([id]) => id !== 'subprojects' || !isChild);
+  // "under <parent>" chip: friendly name from the loaded project list when
+  // available (optional prop), else the last path segment.
+  const parentName = (() => {
+    if (!isChild) return null;
+    const norm = (s) => String(s || '').replace(/[\\/]+$/, '').toLowerCase();
+    const row = (projects || []).find(pr => norm(pr.path) === norm(project.parent_path));
+    if (row && row.name) return row.name;
+    const segs = String(project.parent_path).split(/[\\/]/).filter(Boolean);
+    return segs[segs.length - 1] || project.parent_path;
+  })();
   const renderTab = () => {
     switch (tab) {
+      case 'subprojects':
+        return <DrillSubprojects project={project} onChanged={onChanged} onOpenModal={onOpenModal} />;
       case 'tasks': return <DrillTasks project={project} onChanged={onChanged} />;
       case 'artifacts': return <DrillArtifacts project={project} onChanged={onChanged} />;
       case 'memory': return <DrillMemory project={project} />;
@@ -132,10 +148,23 @@ function DrillPanel({ project, tab, setTab, onClose, onChanged, onOpenModal }) {
         <div style={{ display: 'flex', alignItems: 'center', gap: 10, padding: '16px 20px 8px' }}>
           <GlowDot color={project.active ? T.accent : T.textDim} />
           <div style={{ flex: 1, minWidth: 0 }}>
-            <div style={{
-              fontSize: 15, fontWeight: 700, color: T.text,
-              whiteSpace: 'nowrap', overflow: 'hidden', textOverflow: 'ellipsis',
-            }}>{project.name || project.path}</div>
+            <div style={{ display: 'flex', alignItems: 'center', gap: 8, minWidth: 0 }}>
+              <div style={{
+                fontSize: 15, fontWeight: 700, color: T.text, minWidth: 0,
+                whiteSpace: 'nowrap', overflow: 'hidden', textOverflow: 'ellipsis',
+              }}>{project.name || project.path}</div>
+              {parentName && (
+                <span title={'Sub-project of ' + project.parent_path} style={{
+                  display: 'inline-flex', alignItems: 'center', gap: 4, flexShrink: 0,
+                  fontSize: 10, fontWeight: 600, color: T.textMuted, background: T.surfaceAlt,
+                  border: `1px solid ${T.border}`, borderRadius: 999, padding: '2px 8px',
+                  whiteSpace: 'nowrap',
+                }}>
+                  <I name="gitBranch" size={10} color={T.textMuted} />
+                  under {parentName}
+                </span>
+              )}
+            </div>
             <div className="mono" title={project.path} style={{
               fontSize: 11, color: T.textMuted,
               whiteSpace: 'nowrap', overflow: 'hidden', textOverflow: 'ellipsis',
@@ -152,7 +181,7 @@ function DrillPanel({ project, tab, setTab, onClose, onChanged, onOpenModal }) {
           display: 'flex', gap: 2, padding: '4px 20px 0',
           borderBottom: `1px solid ${T.border}`, overflowX: 'auto', flexShrink: 0,
         }}>
-          {DRILL_PANEL_TABS.map(([id, label]) => (
+          {tabs.map(([id, label]) => (
             <button key={id} onClick={() => setTab(id)} style={{
               background: 'none', border: 'none', cursor: 'pointer', padding: '8px 10px',
               fontSize: 11, fontWeight: 700, textTransform: 'uppercase', letterSpacing: 1,