code-context-control 2.146.0__tar.gz → 2.152.0__tar.gz

{code_context_control-2.146.0 → code_context_control-2.152.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.146.0
+Version: 2.152.0
 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

{code_context_control-2.146.0 → code_context_control-2.152.0}/cli/c3.py

@@ -91,7 +91,7 @@ console = Console() if HAS_RICH else None
 # Config
 CONFIG_DIR = ".c3"
 CONFIG_FILE = ".c3/config.json"
-__version__ = "2.146.0"
+__version__ = "2.152.0"
 
 # The PreToolUse matcher for native subagent calls (installer and hub migration).
 AGENT_MATCHER = "Agent|Task"

{code_context_control-2.146.0 → code_context_control-2.152.0}/cli/guide/tools.html

@@ -1507,6 +1507,7 @@ c3_agent(workflow=<span class="str">'investigate'</span>, context=<span class="s
               <tr><td class="param-name">stats</td><td class="param-desc">Aggregate stats: most-edited files, change frequency</td></tr>
               <tr><td class="param-name">tag</td><td class="param-desc">Tag an edit entry with a label</td></tr>
               <tr><td class="param-name">verify</td><td class="param-desc"><strong>v2.75.0</strong> — did an edit land? Pass the SAME <code>file</code>/<code>old_string</code>/<code>new_string</code> (or <code>edits</code>) a failed or timed-out <code>c3_edit</code> call took. Answers APPLIED (do not retry) / NOT_APPLIED (safe to retry) / INCONCLUSIVE (read the file)</td></tr>
+              <tr><td class="param-name">revert</td><td class="param-desc">Put a file back to the bytes it had before <code>edit_id</code>, from the pre-image <code>c3_edit</code> stored in <code>.c3/edit_blobs/</code>. Refuses if the file changed since (lists the later edit ids to revert first) or if no pre-image was kept (native Edit/shell rows, files over 5 MB, read-denied or masked paths, evicted blobs). Logs its own <code>reverted</code> row, which can itself be reverted.</td></tr>
             </tbody>
           </table>
 

{code_context_control-2.146.0 → code_context_control-2.152.0}/cli/hook_access_guard.py

@@ -447,6 +447,7 @@ def run(payload: dict, project_path: Path | None = None,
     tool_input = payload.get("tool_input", {}) or {}
     base = str(project_path if project_path is not None else Path.cwd())
     session_id = str(payload.get("session_id") or "")
+    ag.bind_session(session_id)
 
     if tool in _WRITE_TOOLS or tool in _READ_TOOLS:
         fp = _target(tool_input)

{code_context_control-2.146.0 → code_context_control-2.152.0}/cli/hub_server.py

@@ -72,6 +72,10 @@ _HUB_CONFIG_DEFAULTS = {
     "projects_view": "list",
     "main_view": "projects",
     "oracle_url": "",
+    # Per-IDE launch command overrides, e.g. {"claude-code": "yep"} when the
+    # agent is started through a wrapper script instead of the stock binary.
+    # A project's own `ide_cmd` (projects.json) wins over this.
+    "ide_cmds": {},
     # Minutes of project silence, with no session heartbeat left, before a UI
     # server that an IDE session launched is stopped. 0 = never reap.
     "ui_reap_minutes": 30,
@@ -81,6 +85,48 @@ _HUB_CONFIG_DEFAULTS = {
 _MAIN_VIEWS = {"projects", "board", "ci", "creds", "tokens", "locks", "access",
                "enforce", "sessions"}
 
+# Stock command per IDE id, and whether it takes the project path as an
+# argument (GUI) instead of being run inside a terminal at that path.
+_IDE_DEFAULT_CMDS = {
+    "claude-code":  ("claude",      False),
+    "claude-app":   ("claude-app",  True),
+    "codex":        ("codex",       False),
+    "grok":         ("grok",        False),
+    "gemini":       ("gemini",      False),
+    "antigravity":  ("antigravity", False),
+    "vscode":       ("code",        True),
+    "cursor":       ("cursor",      True),
+}
+
+
+def _resolve_ide_cmd(ide: str, path: str, custom_cmd: str = "") -> tuple:
+    """Resolve the command to launch for `ide` in `path`.
+
+    Precedence: explicit custom_cmd (this launch) → the project's stored
+    `ide_cmd` → hub config `ide_cmds[ide]` → the stock command.
+    Returns (cmd, is_gui, error) — error is a message when nothing resolves.
+    """
+    default_cmd, is_gui = _IDE_DEFAULT_CMDS.get(ide, ("", False))
+    if ide != "custom" and not default_cmd:
+        return "", False, f"Unknown IDE: {ide}"
+    cmd = (custom_cmd or "").strip()
+    if not cmd:
+        try:
+            cmd = _pm().get_ide_cmd(path)
+        except Exception:
+            cmd = ""
+    if not cmd:
+        overrides = _read_hub_config().get("ide_cmds") or {}
+        if isinstance(overrides, dict):
+            cmd = str(overrides.get(ide) or "").strip()
+    if not cmd:
+        cmd = default_cmd
+    if not cmd:
+        return "", False, "custom_cmd is required for custom IDE"
+    # An overridden command replaces the binary, not the launch style: a
+    # wrapper for a terminal CLI is still a terminal CLI.
+    return cmd, is_gui, ""
+
 # How often the hub reaps orphaned UI servers and chases autostart projects.
 _UI_SWEEP_INTERVAL_S = 60
 
@@ -460,6 +506,15 @@ def api_hub_config_set():
         cfg["main_view"] = main_view
     if "oracle_url" in data:
         cfg["oracle_url"] = str(data["oracle_url"]).strip()
+    if "ide_cmds" in data:
+        raw = data["ide_cmds"]
+        if not isinstance(raw, dict):
+            return jsonify({"error": "ide_cmds must be an object"}), 400
+        # Empty string = "back to the stock command", so the key is dropped
+        # rather than stored blank.
+        cfg["ide_cmds"] = {
+            str(k): str(v).strip() for k, v in raw.items() if str(v or "").strip()
+        }
     if "sidebar_group" in data:
         cfg["sidebar_group"] = str(data["sidebar_group"]).strip()
     if "sidebar_collapsed" in data:
@@ -718,17 +773,11 @@ def api_projects_open():
 
 @app.route("/api/projects/launch-ide", methods=["POST"])
 def api_launch_ide():
-    """Launch an IDE or CLI tool in the project directory. Body: {path, ide, custom_cmd?}"""
-    _IDE_CMDS = {
-        "claude-code":  ("claude",      False),
-        "claude-app":   ("claude-app",  True),
-        "codex":        ("codex",       False),
-        "grok":         ("grok",        False),
-        "gemini":       ("gemini",      False),
-        "antigravity":  ("antigravity", False),
-        "vscode":       ("code",        True),
-        "cursor":       ("cursor",      True),
-    }
+    """Launch an IDE or CLI tool in the project directory. Body: {path, ide, custom_cmd?}
+
+    The command itself is resolved by _resolve_ide_cmd, so a project or the
+    hub can point `claude-code` at a wrapper such as `yep`.
+    """
     try:
         data = request.get_json(force=True) or {}
         path_str   = (data.get("path")       or "").strip()
@@ -744,14 +793,9 @@ def api_launch_ide():
         if not path.exists():
             return jsonify({"error": f"Path does not exist: {path_str}"}), 404
 
-        if ide == "custom":
-            if not custom_cmd:
-                return jsonify({"error": "custom_cmd is required for custom IDE"}), 400
-            cmd, is_gui = custom_cmd, False
-        elif ide in _IDE_CMDS:
-            cmd, is_gui = _IDE_CMDS[ide]
-        else:
-            return jsonify({"error": f"Unknown IDE: {ide}"}), 400
+        cmd, is_gui, err = _resolve_ide_cmd(ide, str(path), custom_cmd)
+        if err:
+            return jsonify({"error": err}), 400
 
         if is_gui:
             # GUI IDEs (VS Code, Cursor) accept a path argument directly
@@ -795,7 +839,7 @@ def api_launch_ide():
 
 @app.route("/api/projects/update", methods=["POST"])
 def api_projects_update():
-    """Update editable project fields (name, tags, notes). Body: {path, name?, tags?, notes?}"""
+    """Update editable project fields. Body: {path, name?, tags?, notes?, ide_cmd?}"""
     data = request.get_json(force=True) or {}
     path = (data.get("path") or "").strip()
     if not path:
@@ -812,6 +856,9 @@ def api_projects_update():
             fields["tags"] = [t.strip() for t in str(raw).split(",") if t.strip()]
     if "notes" in data:
         fields["notes"] = str(data["notes"])
+    if "ide_cmd" in data:
+        # Blank clears the override and falls back to the stock command.
+        fields["ide_cmd"] = str(data["ide_cmd"] or "").strip()
     try:
         ok = _pm().update_project(path, **fields)
         return jsonify({"updated": ok})
@@ -3839,6 +3886,170 @@ def api_hub_access_rule_remove():
     return jsonify(result)
 
 
+# ── Builtin guard modes (v2.147.0) ─────────────────────────────────────────
+
+def _hub_human():
+    """The Desk client behind ``Authorization: Bearer``, else ``None``.
+
+    Loopback and the CSRF guard stop a browser, not a process on this
+    machine: an agent can POST here as easily as a person. A Desk client
+    token is minted only with ``bootstrap.key``, which Access Guard denies
+    to agents, and is stored as a hash, so presenting one is the proof a
+    loosening builtin change needs. A phone token does not count: builtin
+    guards are not loosened from a device that leaves the building.
+    """
+    from oracle.services import client_tokens
+    scheme, _, token = (request.headers.get("Authorization") or "").partition(" ")
+    if scheme.lower() != "bearer" or not token.strip():
+        return None
+    who = client_tokens.principal_for(token.strip())
+    return who if who and who.get("kind") == "desk" else None
+
+
+@app.route("/api/hub/access/builtin", methods=["GET"])
+def api_hub_access_builtin():
+    """Every Tier-1 builtin with its live global mode, and each project's own.
+
+    Modes are read through the keyring (config and attestation must agree),
+    so a mode listed here is one evaluation honours. ``projects`` holds only
+    projects that set a mode of their own, or could not be read.
+    ``strictness`` ranks each mode 0 (allow) to 3 (full deny), so a client
+    can tell loosening from tightening without knowing the tiers.
+    """
+    try:
+        global_modes = access_guard._scope_modes("global")
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+    home = access_guard._global_base()
+    guards = []
+    for glob in access_guard.DISABLEABLE_BUILTINS:
+        canon = access_guard._norm_builtin(glob)
+        guards.append({
+            "glob": canon,
+            "global": global_modes.get(canon, "default"),
+            "strictness": {m: access_guard.builtin_strictness(canon, m)
+                           for m in (*access_guard.BUILTIN_MODES, "default")},
+        })
+    projects = []
+    for p in _pm().list_registered():
+        ppath = str(p.get("path") or "")
+        row = {"name": p.get("name") or Path(ppath).name, "path": ppath,
+               "modes": {}, "error": None}
+        try:
+            base = Path(ppath).resolve()
+            if (base / ".c3").is_dir() and base != home:
+                row["modes"] = access_guard._scope_modes("project", ppath)
+        except Exception as e:
+            row["error"] = str(e)
+        if row["modes"] or row["error"]:
+            projects.append(row)
+    from services import builtin_leases
+    return jsonify({"guards": guards, "projects": projects,
+                    "leases": builtin_leases.active()})
+
+
+@app.route("/api/hub/access/builtin/mode", methods=["POST"])
+def api_hub_access_builtin_mode():
+    """Set a Tier-1 builtin's mode in the global realm or one project's.
+
+    Body: ``{scope, path?, glob, mode, confirm?}``. A mode at least as strict
+    as the live one needs nothing more. A looser one needs a Desk client
+    token (403 ``needs_human`` without it) and ``confirm`` equal to the glob
+    (400 ``needs_confirmation``). A project is judged against what its
+    agents see today, which is the global mode unless it set its own.
+    """
+    data = request.get_json(silent=True) or {}
+    scope, project, err = _hub_access_target(data)
+    if err:
+        return err
+    glob = str(data.get("glob") or "")
+    mode = str(data.get("mode") or "").strip()
+    canon = access_guard._norm_builtin(glob)
+    try:
+        new = access_guard.builtin_strictness(canon, mode)
+        live = (access_guard._scope_modes("global") if scope == "global"
+                else access_guard.effective_builtin_modes(project))
+        old = access_guard.builtin_strictness(canon, live.get(canon, "default"))
+    except ValueError as exc:
+        return jsonify({"error": str(exc)}), 400
+    if new < old:
+        if _hub_human() is None:
+            return jsonify({
+                "error": "loosening a built-in guard needs C3 Desk",
+                "needs_human": True,
+                "command": f'c3 access builtin mode "{canon}" {mode}'
+                           + (f' --project --path "{project}"'
+                              if scope == "project" else ""),
+            }), 403
+        if access_guard._norm_builtin(data.get("confirm")) != canon:
+            return jsonify({
+                "error": "loosening a built-in guard weakens protection",
+                "needs_confirmation": True, "confirm_with": canon,
+            }), 400
+    try:
+        result = access_guard.set_builtin_mode(canon, mode, scope,
+                                               project or ".")
+    except ValueError as exc:
+        return jsonify({"error": str(exc)}), 400
+    if result["changed"]:
+        _hub_access_audit(f"builtin_mode_{result['mode']}", result["glob"],
+                          "builtin", scope, project)
+    return jsonify({**result, "loosened": new < old})
+
+
+@app.route("/api/hub/access/builtin/lease", methods=["POST"])
+def api_hub_access_builtin_lease():
+    """Loosen a builtin for a while: every session, or one.
+
+    Body: ``{scope, path?, glob, mode, ttl_s, session_id?, confirm}``. A
+    lease only ever loosens, so it always needs a Desk client token and the
+    glob typed back, and a lease no looser than the live mode is a 400
+    rather than a row that would never apply. ``ttl_s`` is 60 s to 8 h.
+    """
+    from services import builtin_leases
+    data = request.get_json(silent=True) or {}
+    scope, project, err = _hub_access_target(data)
+    if err:
+        return err
+    who = _hub_human()
+    if who is None:
+        return jsonify({"error": "a temporary built-in change needs C3 Desk",
+                        "needs_human": True}), 403
+    canon = access_guard._norm_builtin(data.get("glob"))
+    mode = str(data.get("mode") or "").strip()
+    if access_guard._norm_builtin(data.get("confirm")) != canon or not canon:
+        return jsonify({"error": "a temporary change weakens protection",
+                        "needs_confirmation": True, "confirm_with": canon}), 400
+    try:
+        live = access_guard.effective_builtin_modes(project or ".") \
+            if scope == "project" else access_guard._scope_modes("global")
+        if access_guard.builtin_strictness(canon, mode) >= \
+                access_guard.builtin_strictness(canon, live.get(canon, "default")):
+            return jsonify({"error": f"{canon} is already {live.get(canon, 'default')}"
+                            f" — a {mode} lease would change nothing"}), 400
+        row = builtin_leases.mint(
+            canon, mode, scope=scope, project_path=project or ".",
+            session_id=str(data.get("session_id") or ""),
+            ttl_s=data.get("ttl_s"), created_by=who["client_id"])
+    except ValueError as exc:
+        return jsonify({"error": str(exc)}), 400
+    _hub_access_audit(f"builtin_lease_{mode}", canon, "builtin", scope, project)
+    return jsonify({"lease": row})
+
+
+@app.route("/api/hub/access/builtin/lease/revoke", methods=["POST"])
+def api_hub_access_builtin_lease_revoke():
+    """End a lease now. Tightening, so no token. Body: ``{id}``."""
+    from services import builtin_leases
+    lease_id = str((request.get_json(silent=True) or {}).get("id") or "")
+    gone = builtin_leases.revoke(lease_id) if lease_id else None
+    if gone is None:
+        return jsonify({"error": "unknown or already-expired lease"}), 404
+    _hub_access_audit("builtin_lease_revoke", gone["glob"], "builtin",
+                      gone["scope"], gone.get("project_path") or None)
+    return jsonify({"revoked": lease_id})
+
+
 # ── Project management: tasks / milestones / notes (v2.45.0) ──────────────
 # Direct TaskStore per request (reload-per-op store — no runtime build needed
 # for mutations); every write audited to the target project's activity log.

{code_context_control-2.146.0 → code_context_control-2.152.0}/cli/hub_ui/components/hub_access.js

@@ -19,8 +19,9 @@
 //     hand — the server enforces that regardless of what this UI believes);
 //   - a request that lapsed while the page showed it refreshes to its real
 //     status (the decide route answers 409), never silently mints a grant;
-//   - rule MUTATION stays on the per-project server and `c3 access` — this
-//     tab approves and reads, it does not edit policy.
+//   - path-rule MUTATION stays on the per-project server and `c3 access`.
+//     Builtin guards may be TIGHTENED here; loosening one needs C3 Desk or
+//     the CLI, because this page holds no proof that a person clicked.
 
 const ACC_KIND_COLOR = (kind) => (
   kind === 'deny' ? T.error : kind === 'mask' ? T.blue
@@ -387,6 +388,121 @@ function AccRulesPanel({ projects, focus }) {
   );
 }
 
+// ── Builtin guards ─────────────────────────────────────────────────────────
+// The global mode of every Tier-1 builtin. Picking a stricter mode applies
+// it; picking a looser one is refused by the server without a Desk token,
+// and the panel shows the CLI command instead.
+const ACC_BUILTIN_MODES = ['default', 'deny', 'confirm', 'allow'];
+
+function AccBuiltinPanel() {
+  const [data, setData] = useState(null);
+  const [err, setErr] = useState('');
+  const [busy, setBusy] = useState('');
+  const [needs, setNeeds] = useState(null);
+
+  const load = useCallback(async () => {
+    try { setData(await api.get('/api/hub/access/builtin')); setErr(''); }
+    catch (e) { setErr(apiErr(e)); }
+  }, []);
+  useEffect(() => { load(); }, [load]);
+  usePoll(load, 15000);
+
+  const setMode = async (g, mode) => {
+    setBusy(g.glob); setNeeds(null);
+    try {
+      await api.post('/api/hub/access/builtin/mode', { scope: 'global', glob: g.glob, mode });
+      notify(`${g.glob} is now ${mode} everywhere`, 'ok');
+    } catch (e) {
+      const body = e && e.payload;
+      if (body && body.needs_human) setNeeds({ glob: g.glob, command: body.command });
+      else notify(apiErr(e), 'err');
+    }
+    setBusy('');
+    load();
+  };
+
+  const revoke = async (l) => {
+    setBusy(l.id);
+    try {
+      await api.post('/api/hub/access/builtin/lease/revoke', { id: l.id });
+      notify(`Ended the ${l.mode} lease on ${l.glob}`, 'ok');
+    } catch (e) { notify(apiErr(e), 'err'); }
+    setBusy('');
+    load();
+  };
+
+  const projects = (data && data.projects) || [];
+  const leases = (data && data.leases) || [];
+  return (
+    <div style={{
+      background: T.surface, border: `1px solid ${T.border}`, borderRadius: 10,
+      padding: '12px 16px',
+    }}>
+      <div style={{ display: 'flex', alignItems: 'center', gap: 10, flexWrap: 'wrap' }}>
+        <div style={{ fontSize: 12.5, fontWeight: 700, color: T.text }}>Built-in guards</div>
+        <span style={{ fontSize: 10.5, color: T.textDim }}>
+          global mode — a stricter mode applies here; loosening one needs C3 Desk or the CLI
+        </span>
+      </div>
+      {err && <div style={{ marginTop: 8, fontSize: 11.5, color: T.error }}>{err}</div>}
+      {needs && (
+        <div style={{ marginTop: 8, fontSize: 11.5, color: T.warn }}>
+          Loosening <span className="mono">{needs.glob}</span> needs C3 Desk, or run:{' '}
+          <span className="mono" style={{ color: T.text }}>{needs.command}</span>
+        </div>
+      )}
+      {data && (
+        <div style={{ marginTop: 10, display: 'grid', gridTemplateColumns: 'minmax(0,1fr) auto', gap: '4px 12px', alignItems: 'center' }}>
+          {data.guards.map(g => (
+            <React.Fragment key={g.glob}>
+              <span className="mono" style={{ fontSize: 11.5, color: T.text, overflow: 'hidden', textOverflow: 'ellipsis' }}>{g.glob}</span>
+              <select value={g.global} disabled={busy === g.glob}
+                onChange={e => setMode(g, e.target.value)}
+                style={{
+                  background: T.surfaceAlt, color: g.global === 'default' ? T.textMuted : T.warn,
+                  border: `1px solid ${T.border}`, borderRadius: 6, fontSize: 11.5, padding: '2px 6px',
+                }}>
+                {ACC_BUILTIN_MODES.map(m => <option key={m} value={m}>{m}</option>)}
+              </select>
+            </React.Fragment>
+          ))}
+        </div>
+      )}
+      {leases.length > 0 && (
+        <div style={{ marginTop: 10, display: 'flex', flexDirection: 'column', gap: 4 }}>
+          <div style={{ fontSize: 10.5, fontWeight: 700, letterSpacing: 1, textTransform: 'uppercase', color: T.warn }}>
+            temporary changes
+          </div>
+          {leases.map(l => (
+            <div key={l.id} style={{ display: 'flex', alignItems: 'center', gap: 8, fontSize: 11.5 }}>
+              <span className="mono" style={{ color: T.text }}>{l.glob}</span>
+              <span style={{ color: T.warn }}>{l.mode}</span>
+              <span style={{ color: T.textMuted }}>
+                {l.scope === 'project' ? l.project_path : 'all projects'}
+                {' · '}{l.session_id ? <>session <span className="mono">{l.session_id.slice(0, 8)}</span></> : 'all sessions'}
+                {' · '}ends in {accExpiresIn(l.expires_at) || '—'}
+              </span>
+              <div style={{ flex: 1 }} />
+              <Btn variant="ghost" disabled={busy === l.id} onClick={() => revoke(l)}>Revoke</Btn>
+            </div>
+          ))}
+        </div>
+      )}
+      {projects.length > 0 && (
+        <div style={{ marginTop: 8, fontSize: 11, color: T.textDim }}>
+          Set per project:{' '}
+          {projects.map(p => (
+            <span key={p.path} className="mono" style={{ marginRight: 10 }}>
+              {p.name}: {p.error ? `unreadable (${p.error})`
+                : Object.entries(p.modes).map(([g, m]) => `${g}=${m}`).join(', ')}
+            </span>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}
+
 // ── Active grants ──────────────────────────────────────────────────────────
 // A rule grant can authorise many calls over hours. The only other place it
 // shows up is a line in the agent's own transcript, which is the wrong place
@@ -762,6 +878,7 @@ function HubAccess({ projects }) {
       )}
 
       <AccGrantsPanel projects={projects} />
+      <AccBuiltinPanel />
       <AccRulesPanel projects={projects} focus={ruleFocus} />
       {confirmSpec && (
         <CredConfirm spec={confirmSpec} onClose={() => setConfirmSpec(null)} />

{code_context_control-2.146.0 → code_context_control-2.152.0}/cli/hub_ui/components/modals.js

@@ -528,24 +528,41 @@ function ReparentModal({ project, projects, onClose, onChanged }) {
 
 // ── IDE picker ─────────────────────────────────────────────────
 // POST /api/projects/launch-ide {path, ide, custom_cmd?}
+// The command is editable per project (stored as ide_cmd via
+// /api/projects/update) so an agent started through a wrapper — `yep` rather
+// than `claude` — launches from the card too, not just from here.
 function IdePickerModal({ project, onClose, onChanged }) {
   const known = IDE_OPTIONS.some(o => o.id === (project && project.ide));
   const [selected, setSelected] = useState(known ? project.ide : 'claude-code');
-  const [customCmd, setCustomCmd] = useState('');
+  const savedCmd = ((project && project.ide_cmd) || '').trim();
+  const [customCmd, setCustomCmd] = useState(savedCmd);
+  const [remember, setRemember] = useState(!!savedCmd);
   const [busy, setBusy] = useState(false);
 
+  const stockCmd = (id) => {
+    const opt = IDE_OPTIONS.find(o => o.id === id);
+    return opt && opt.cmd !== '...' ? opt.cmd : '';
+  };
+  const effectiveCmd = customCmd.trim() || stockCmd(selected);
+
   const launch = async () => {
-    if (selected === 'custom' && !customCmd.trim()) {
+    const cmd = customCmd.trim();
+    if (selected === 'custom' && !cmd) {
       notify('Enter a custom command first.', 'err');
       return;
     }
     setBusy(true);
     try {
+      // Persist first: the project card launches with no command of its own.
+      const wanted = remember ? cmd : '';
+      if (wanted !== savedCmd) {
+        await api.post('/api/projects/update', { path: project.path, ide_cmd: wanted });
+      }
       await api.post('/api/projects/launch-ide', {
-        path: project.path, ide: selected,
-        custom_cmd: selected === 'custom' ? customCmd.trim() : '',
+        path: project.path, ide: selected, custom_cmd: cmd,
       });
-      notify(`Launched ${ideLabel(selected)} in ${project.name || project.path}`);
+      notify(`Launched ${ideLabel(selected)} (${effectiveCmd}) in ${project.name || project.path}`);
+      if (onChanged) onChanged();
       onClose();
     } catch (e) {
       notify(`Launch failed: ${e.message}`, 'err');
@@ -575,13 +592,18 @@ function IdePickerModal({ project, onClose, onChanged }) {
           );
         })}
       </div>
-      {selected === 'custom' && (
-        <div>
-          <MdlLabel>Custom command</MdlLabel>
-          <input value={customCmd} onChange={e => setCustomCmd(e.target.value)}
-            placeholder="e.g. nvim ." className="mono" style={mdlInputStyle()} />
-        </div>
-      )}
+      <div>
+        <MdlLabel>Command{selected === 'custom' ? '' : ' (leave blank for the default)'}</MdlLabel>
+        <input value={customCmd} onChange={e => setCustomCmd(e.target.value)}
+          placeholder={selected === 'custom' ? 'e.g. nvim .' : `${stockCmd(selected)} — override with e.g. yep`}
+          className="mono" style={mdlInputStyle()} />
+        <label style={{ display: 'flex', alignItems: 'center', gap: 6, marginTop: 6,
+          fontSize: 11, color: T.textMuted, cursor: 'pointer' }}>
+          <input type="checkbox" checked={remember}
+            onChange={e => setRemember(e.target.checked)} />
+          Remember for this project (used by the card's launch button too)
+        </label>
+      </div>
       <MdlFooter>
         <Btn variant="ghost" onClick={onClose}>Cancel</Btn>
         <Btn onClick={launch} disabled={busy}>

{code_context_control-2.146.0 → code_context_control-2.152.0}/cli/hub_ui/components/settings_modal.js

@@ -14,6 +14,7 @@ function SettingsModal({ onClose, onChanged }) {
   const [port, setPort] = useState('');
   const [autoBrowser, setAutoBrowser] = useState(true);
   const [oracleUrl, setOracleUrl] = useState('');
+  const [agentCmd, setAgentCmd] = useState('');   // ide_cmds['claude-code']
   const [cacheSize, setCacheSize] = useState(8);
   const [saving, setSaving] = useState(false);
   const [svc, setSvc] = useState(null);            // hub: {installed, running, method, port, log_path} | {error}
@@ -51,6 +52,7 @@ function SettingsModal({ onClose, onChanged }) {
         setPort(d.port || 3330);
         setAutoBrowser(!!d.auto_open_browser);
         setOracleUrl(d.oracle_url || '');
+        setAgentCmd(((d.ide_cmds || {})['claude-code']) || '');
         setCacheSize(d.runtime_cache_size || 8);
       } catch {
         notify('Could not load hub config', 'err');
@@ -70,9 +72,14 @@ function SettingsModal({ onClose, onChanged }) {
     const cache = Math.max(1, parseInt(cacheSize, 10) || 8);
     setSaving(true);
     try {
+      // Blank restores the stock `claude`; other IDE overrides are left alone.
+      const ideCmds = { ...((cfg && cfg.ide_cmds) || {}) };
+      if (agentCmd.trim()) ideCmds['claude-code'] = agentCmd.trim();
+      else delete ideCmds['claude-code'];
       await api.post('/api/hub/config', {
         port: portVal, auto_open_browser: autoBrowser,
         oracle_url: oracleUrl.trim(), runtime_cache_size: cache,
+        ide_cmds: ideCmds,
       });
       const portChanged = cfg && portVal !== cfg.port;
       notify(portChanged
@@ -222,6 +229,10 @@ function SettingsModal({ onClose, onChanged }) {
         <input type="number" value={cacheSize} onChange={e => setCacheSize(e.target.value)}
           min={1} className="mono" style={inputStyle(110)} />
       ), 'Max project runtimes kept warm for drill-in and global search.')}
+      {fieldRow('Agent command', (
+        <input value={agentCmd} onChange={e => setAgentCmd(e.target.value)}
+          placeholder="claude" className="mono" style={inputStyle(220)} />
+      ), 'Default command for "Claude Code CLI" launches — e.g. yep for a wrapper script. A project can override it in Open in IDE.')}
       {fieldRow('Oracle URL', (
         <input value={oracleUrl} onChange={e => setOracleUrl(e.target.value)}
           placeholder="http://localhost:3331" className="mono" style={inputStyle(220)} />