code-context-control 2.89.1__tar.gz → 2.92.0__tar.gz

{code_context_control-2.89.1/code_context_control.egg-info → code_context_control-2.92.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.89.1
+Version: 2.92.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
@@ -137,7 +137,7 @@ Full notes: [Upgrading](https://github.com/drknowhow/code-context-control/blob/m
 
 ## The UI
 
-Three local web apps, no Electron — pure Flask + vanilla JS: the **Hub** (`c3 hub`, port 3330), the **per-project UI** (`c3 ui`), and the optional **Oracle** (`c3 oracle serve`).
+Three local web apps, no Electron — pure Flask + vanilla JS: the **Hub** (`c3 hub`, port 3330), the **per-project UI** (`c3 ui`), and the optional **Oracle** (`c3 oracle serve`). Both servers can run as windowless login services — `c3 hub --install`, `c3 oracle serve --install`, or the buttons in Hub → Settings.
 
 ### Project Hub — multi-project mission control
 

{code_context_control-2.89.1 → code_context_control-2.92.0}/README.md

@@ -74,7 +74,7 @@ Full notes: [Upgrading](https://github.com/drknowhow/code-context-control/blob/m
 
 ## The UI
 
-Three local web apps, no Electron — pure Flask + vanilla JS: the **Hub** (`c3 hub`, port 3330), the **per-project UI** (`c3 ui`), and the optional **Oracle** (`c3 oracle serve`).
+Three local web apps, no Electron — pure Flask + vanilla JS: the **Hub** (`c3 hub`, port 3330), the **per-project UI** (`c3 ui`), and the optional **Oracle** (`c3 oracle serve`). Both servers can run as windowless login services — `c3 hub --install`, `c3 oracle serve --install`, or the buttons in Hub → Settings.
 
 ### Project Hub — multi-project mission control
 

{code_context_control-2.89.1 → code_context_control-2.92.0}/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.89.1"
+__version__ = "2.92.0"
 
 
 def _compress_file_cli(compressor, path, mode="smart", **kw):
@@ -845,7 +845,8 @@ def _prompt_memory_llm(project_path: str) -> None:
           + ("cloud + local fallback." if section["cloud_enabled"] else "local only (private)."))
 
 
-def _prompt_init_steps(project_path: str, ide_name: str, default_mode: str = "direct") -> tuple[str, bool]:
+def _prompt_init_steps(project_path: str, ide_name: str, default_mode: str = "direct",
+                       shape=None) -> tuple[str, bool]:
     """Run guided post-init setup steps for Git and MCP."""
     chosen_ide = _select_init_ide(ide_name or "auto")
     save_config({"ide": chosen_ide}, project_path)
@@ -916,7 +917,7 @@ def _prompt_init_steps(project_path: str, ide_name: str, default_mode: str = "di
                 )
                 include_wildcard = bool(wildcard_choice and wildcard_choice.startswith("Yes"))
 
-    chosen_enforcement = _prompt_enforcement(chosen_tier)
+    chosen_enforcement = _prompt_enforcement(chosen_tier, shape=shape)
 
     _run_install_mcp(project_path, chosen_ide, mcp_mode=mcp_mode,
                      permissions=chosen_tier, include_mcp_wildcard=include_wildcard,
@@ -924,9 +925,70 @@ def _prompt_init_steps(project_path: str, ide_name: str, default_mode: str = "di
     return chosen_ide, True
 
 
-def _prompt_enforcement(chosen_tier: str | None) -> str | None:
+def _assess_repo_shape(project_path: str):
+    """Measure the project (services.repo_shape). None when it cannot be measured."""
+    try:
+        from services import repo_shape
+        return repo_shape.assess(project_path)
+    except Exception:
+        _log.debug("repo shape assessment failed", exc_info=True)
+        return None
+
+
+def _apply_repo_shape_default(project_path: str, explicit_enforcement: str | None = None,
+                              shape=None) -> None:
+    """Say what kind of project this is, and default a prose one to ``advisory``.
+
+    Field report 2026-08-22: a 636-file project, ~95% Markdown and .docx,
+    where every symbol-aware C3 tool had nothing to act on and strict
+    discipline was paid on every turn until C3 was uninstalled. The shape
+    is printed for every project; the default is written only for the prose
+    kind, only over a tier-derived or unset mode (never over ``c3 enforce``
+    or ``--enforcement``), with provenance ``set_by: repo-shape`` so
+    ``c3 enforce`` shows where it came from, and with the way back printed.
+    """
+    try:
+        from services import enforcement_policy as ep
+        from services import repo_shape
+    except Exception:
+        return
+    if shape is None:
+        shape = _assess_repo_shape(project_path)
+    if shape is None or shape.kind == repo_shape.KIND_EMPTY:
+        return
+    print(f"\n  Repo shape: {shape.describe()}")
+    mode = repo_shape.recommended_mode(shape)
+    if not mode:
+        return
+    if explicit_enforcement:
+        print(f"      Prose-heavy, but --enforcement {explicit_enforcement} was given — leaving it as set.")
+        return
+    current = ep.resolve(project_path)
+    if current.set_by == ep.SET_BY_USER:
+        print(f"      Prose-heavy; tool discipline stays '{current.mode}' (your choice).")
+        return
+    if current.mode == mode:
+        print(f"      Prose-heavy; tool discipline is already '{mode}'.")
+        return
+    try:
+        result = ep.set_mode(mode, project_path, set_by=ep.SET_BY_SHAPE, scope="project")
+    except ValueError:
+        return
+    if result.get("deferred"):
+        return
+    print("  [!] This is a documentation project: C3's symbol-aware tools (compress/read/impact/")
+    print(f"      validate/CI) have little to act on here, so tool discipline is set to '{mode}' —")
+    print("      native Edit/Write are allowed with a nudge and the edit ledger still records them.")
+    print("      `c3 enforce strict` restores the hard block; `c3 enforce` shows the setting.")
+
+
+def _prompt_enforcement(chosen_tier: str | None, shape=None) -> str | None:
     """Step 5/5 — tool discipline. Returns an explicit mode, or None to derive.
 
+    ``shape`` (services.repo_shape.RepoShape) moves the suggested default to
+    ``advisory`` for a documentation project and says why, so the user is
+    not asked to guess what C3's symbol tools will do with 600 Markdown files.
+
     Asked separately from the permission tier because it answers a genuinely
     different question: the tier controls what the IDE will let the agent call,
     this controls how hard C3's own hook pushes it toward c3_* tools. Users hit
@@ -938,8 +1000,18 @@ def _prompt_enforcement(chosen_tier: str | None) -> str | None:
         return None
 
     default_mode = ep.derive_from_tier(chosen_tier) if chosen_tier else ep.MODE_ADVISORY
+    suggested_by = "Your permission tier suggests"
+    try:
+        from services import repo_shape
+        shape_mode = repo_shape.recommended_mode(shape) if shape is not None else None
+    except Exception:
+        shape_mode = None
+    if shape_mode:
+        default_mode = shape_mode
+        suggested_by = ("This is a documentation project — C3's symbol tools have "
+                        "little to act on here. Suggested")
     print()
-    print(f"  (Your permission tier suggests: {default_mode})")
+    print(f"  ({suggested_by}: {default_mode})")
     choice = _prompt_choice(
         "Step 5/5 — Tool discipline: how hard should C3 push toward c3_* tools?",
         [
@@ -1085,6 +1157,7 @@ def cmd_init(args):
     if not c3_dir.exists() or not (c3_dir / "config.json").exists():
         print_header(f"Initializing C3 for: {project_path}")
         _do_init(project_path, ide_name=requested_ide, no_embed=no_embed)
+        shape = _assess_repo_shape(project_path)
         try:
             from services.project_manager import ProjectManager
             ProjectManager().add_project(project_path)
@@ -1101,7 +1174,11 @@ def cmd_init(args):
                 enforcement=getattr(args, "enforcement", None),
             )
         else:
-            _prompt_init_steps(project_path, requested_ide, default_mode=getattr(args, "mcp_mode", "direct"))
+            _prompt_init_steps(project_path, requested_ide,
+                               default_mode=getattr(args, "mcp_mode", "direct"), shape=shape)
+        _apply_repo_shape_default(project_path,
+                                  explicit_enforcement=getattr(args, "enforcement", None),
+                                  shape=shape)
         # Detect Codex CLI availability
         try:
             from cli.tools.delegate import check_codex
@@ -1285,11 +1362,7 @@ def cmd_init(args):
         if c3_dir.exists():
             shutil.rmtree(c3_dir)
             print("  Deleted .c3/")
-        for filename, _ in _instruction_documents_for_project():
-            p = Path(project_path) / filename
-            if p.exists():
-                p.unlink()
-                print(f"  Deleted {filename}")
+        _remove_c3_instruction_docs(project_path)
         print("\n[OK] C3 project files removed.")
         return
 
@@ -1361,9 +1434,10 @@ def cmd_init(args):
 
     elif selected.startswith("Wipe"):
         confirm = input(
-            "\n  WARNING: This will permanently delete .c3/ and all project\n"
-            "  instruction files (CLAUDE.md, GEMINI.md, AGENTS.md), and remove\n"
-            "  C3 MCP configurations from your IDE. Type 'yes' to confirm: "
+            "\n  WARNING: This will permanently delete .c3/, remove C3's managed\n"
+            "  block from CLAUDE.md / AGENTS.md / GEMINI.md (a file is deleted only\n"
+            "  when nothing else is in it), and remove C3 MCP configurations from\n"
+            "  your IDE. Type 'yes' to confirm: "
         ).strip().lower()
         if confirm != "yes":
             print("  Wipe cancelled.")
@@ -1375,11 +1449,7 @@ def cmd_init(args):
             shutil.rmtree(c3_dir)
             print("  Deleted .c3/")
 
-        for filename, _ in _instruction_documents_for_project():
-            p = Path(project_path) / filename
-            if p.exists():
-                p.unlink()
-                print(f"  Deleted {filename}")
+        _remove_c3_instruction_docs(project_path)
 
         print("\n[OK] C3 project files removed.")
 
@@ -4555,6 +4625,115 @@ def _ensure_global_session_fallbacks(server_script: str, c3_mcp_exe: str | None
             print(f"Warning: Could not update {antigravity_path} (global fallback skipped)")
 
 
+# Every hook script C3 has ever registered in a settings file — the v2.42+
+# dispatcher plus the pre-v2.42 per-hook scripts — so uninstall recognises an
+# entry written by any C3 version. A user hook is anything not naming one.
+_C3_HOOK_SCRIPTS = (
+    "hook_dispatch.py",
+    "hook_access_guard.py", "hook_artifact.py", "hook_auto_snapshot.py",
+    "hook_c3_signal.py", "hook_c3read.py", "hook_edit_ledger.py",
+    "hook_edit_unlock.py", "hook_filter.py", "hook_ghost_files.py",
+    "hook_pretool_enforce.py", "hook_prompt_recall.py", "hook_read.py",
+    "hook_session_stats.py", "hook_terse_advisor.py",
+)
+
+
+def _is_c3_hook_command(command) -> bool:
+    return any(script in str(command or "") for script in _C3_HOOK_SCRIPTS)
+
+
+def _is_c3_permission(rule) -> bool:
+    """``mcp__c3__<tool>``, ``mcp__c3__*``, or the bare ``mcp__c3`` server grant."""
+    r = str(rule or "").strip()
+    return r == "mcp__c3" or r.startswith("mcp__c3__")
+
+
+def _c3_references_in_settings(settings: dict) -> list:
+    """Every C3-owned entry present in a settings dict: hook commands (named
+    by event) and permission rules. Used to decide whether there is anything
+    to remove and, after writing, to check that it was actually removed."""
+    refs: list = []
+    hooks = settings.get("hooks")
+    if isinstance(hooks, dict):
+        for event, groups in hooks.items():
+            for group in groups or []:
+                if not isinstance(group, dict):
+                    continue
+                for hk in group.get("hooks") or []:
+                    if isinstance(hk, dict) and _is_c3_hook_command(hk.get("command")):
+                        refs.append(f"hooks.{event}")
+    perms = settings.get("permissions")
+    if isinstance(perms, dict):
+        for key in ("allow", "deny", "ask"):
+            for rule in perms.get(key) or []:
+                if _is_c3_permission(rule):
+                    refs.append(f"permissions.{key}:{rule}")
+    if "c3" in (settings.get("enabledMcpjsonServers") or []):
+        refs.append("enabledMcpjsonServers:c3")
+    return refs
+
+
+def _strip_c3_from_settings(settings: dict) -> dict:
+    """Remove every C3-owned entry from a Claude Code settings dict (in place,
+    and returned). Touches ONLY what C3 wrote: hook entries whose command runs
+    a C3 hook script — any event, any matcher; the previous cleanup looked at
+    three PostToolUse matchers from the pre-v2.42 layout and nothing else, so
+    PreToolUse/Stop/UserPromptSubmit and the whole ``permissions.allow`` list
+    survived an "uninstall" — plus ``mcp__c3__*`` permission rules and the
+    ``c3`` MCP-server enablement. User hooks, user permission rules and every
+    other key are left exactly as found; containers emptied by the removal
+    are dropped so a file C3 created alone ends up empty (and the caller
+    deletes it) rather than as ``{"hooks": {}}``.
+    """
+    hooks = settings.get("hooks")
+    if isinstance(hooks, dict):
+        for event in list(hooks.keys()):
+            kept_groups = []
+            for group in hooks.get(event) or []:
+                if not isinstance(group, dict):
+                    kept_groups.append(group)
+                    continue
+                entries = group.get("hooks") or []
+                if not any(isinstance(hk, dict) and _is_c3_hook_command(hk.get("command"))
+                           for hk in entries):
+                    kept_groups.append(group)  # not ours — untouched
+                    continue
+                kept = [hk for hk in entries
+                        if not (isinstance(hk, dict) and _is_c3_hook_command(hk.get("command")))]
+                if kept:
+                    group = dict(group)
+                    group["hooks"] = kept
+                    kept_groups.append(group)
+            if kept_groups:
+                hooks[event] = kept_groups
+            else:
+                del hooks[event]
+        if not hooks:
+            del settings["hooks"]
+
+    perms = settings.get("permissions")
+    if isinstance(perms, dict):
+        for key in ("allow", "deny", "ask"):
+            rules = perms.get(key)
+            if isinstance(rules, list) and any(_is_c3_permission(r) for r in rules):
+                kept_rules = [r for r in rules if not _is_c3_permission(r)]
+                if kept_rules:
+                    perms[key] = kept_rules
+                else:
+                    del perms[key]
+        if not perms:
+            del settings["permissions"]
+
+    enabled = settings.get("enabledMcpjsonServers")
+    if isinstance(enabled, list) and "c3" in enabled:
+        enabled = [s for s in enabled if s != "c3"]
+        if enabled:
+            settings["enabledMcpjsonServers"] = enabled
+        else:
+            del settings["enabledMcpjsonServers"]
+    return settings
+
+
 def _uninstall_mcp_all(project_path: str, include_global: bool = True):
     """Remove C3 MCP server configurations from all supported IDEs.
 
@@ -4658,37 +4837,28 @@ def _uninstall_mcp_all(project_path: str, include_global: bool = True):
                     with open(settings_path, 'r', encoding="utf-8") as f:
                         settings = json.load(f)
 
-                    # Remove hooks
-                    hooks = settings.get("hooks", {}).get("PostToolUse", [])
-                    new_hooks = []
-                    c3_hook_files = {"hook_filter.py", "hook_read.py", "hook_c3read.py", "hook_dispatch.py"}
-                    for h in hooks:
-                        if h.get("matcher") in ("Bash", "Read", "mcp__c3__c3_read"):
-                            h["hooks"] = [hook for hook in h.get("hooks", [])
-                                          if not any(f in hook.get("command", "") for f in c3_hook_files)]
-                            if h["hooks"]:
-                                new_hooks.append(h)
-                        else:
-                            new_hooks.append(h)
-
-                    if new_hooks:
-                        settings["hooks"]["PostToolUse"] = new_hooks
-                    elif "hooks" in settings and "PostToolUse" in settings["hooks"]:
-                        del settings["hooks"]["PostToolUse"]
-                        if not settings["hooks"]:
-                            del settings["hooks"]
-
-                    # Remove enabled server
-                    if "enabledMcpjsonServers" in settings and "c3" in settings["enabledMcpjsonServers"]:
-                        settings["enabledMcpjsonServers"].remove("c3")
-
-                    if not settings:
-                        settings_path.unlink()
-                        print(f"  Deleted empty {settings_path}")
+                    before = _c3_references_in_settings(settings)
+                    if not before:
+                        print(f"  No C3 entries in {settings_path}")
                     else:
-                        with open(settings_path, 'w', encoding="utf-8") as f:
-                            json.dump(settings, f, indent=2)
-                        print(f"  Removed C3 hooks/settings from {settings_path}")
+                        settings = _strip_c3_from_settings(settings)
+                        if not settings:
+                            settings_path.unlink()
+                            print(f"  Deleted empty {settings_path}")
+                        else:
+                            with open(settings_path, 'w', encoding="utf-8") as f:
+                                json.dump(settings, f, indent=2)
+                            # Postcondition: re-read what is on disk and report
+                            # what is true, not what was attempted.
+                            with open(settings_path, 'r', encoding="utf-8") as f:
+                                remaining = _c3_references_in_settings(json.load(f))
+                            if remaining:
+                                shown = ", ".join(remaining[:5]) + (" ..." if len(remaining) > 5 else "")
+                                print(f"  [!] C3 entries remain in {settings_path} "
+                                      f"({len(remaining)}): {shown}")
+                            else:
+                                print(f"  Removed C3 hooks/settings from {settings_path} "
+                                      f"({len(before)} entries)")
                 except Exception as e:
                     print(f"  Warning: Could not update {settings_path}: {e}")
 
@@ -4872,6 +5042,44 @@ def _instruction_documents_for_project() -> list[tuple[str, str]]:
     ]
 
 
+def _remove_c3_instruction_docs(project_path: str) -> None:
+    """Take C3's managed block OUT of every instruction doc it ever wrote.
+
+    Uninstall counterpart of ``_sync_project_instruction_docs``. Before
+    v2.92 this was a bare ``unlink()`` of CLAUDE.md / AGENTS.md / GEMINI.md —
+    which, in a project whose CLAUDE.md also carried another tool's managed
+    block (``<!-- YEP:BEGIN -->``) or the user's own notes, destroyed content
+    C3 never owned, with no warning and no way back unless git had it.
+    Same rule every regeneration path already follows: C3 owns its slice,
+    everything outside the markers is preserved. A file is deleted only when
+    the block was all there was.
+    """
+    from services.claude_md import strip_c3_block
+
+    for filename, _ in _instruction_documents_for_project():
+        p = Path(project_path) / filename
+        if not p.exists():
+            continue
+        try:
+            existing = p.read_text(encoding="utf-8", errors="replace")
+        except OSError as exc:
+            print(f"  Warning: Could not read {filename}: {exc}")
+            continue
+        remainder = strip_c3_block(existing)
+        if remainder is None:
+            print(f"  Kept {filename} (no C3 block in it — not ours to delete)")
+        elif remainder.strip():
+            try:
+                p.write_text(remainder, encoding="utf-8")
+            except OSError as exc:
+                print(f"  Warning: Could not update {filename}: {exc}")
+                continue
+            print(f"  Removed C3 block from {filename} (kept the rest of the file)")
+        else:
+            p.unlink()
+            print(f"  Deleted {filename}")
+
+
 _LEGACY_INSTRUCTION_DOCS = ("GEMINI.md",)  # Gemini CLI profile removed in v2.52
 
 
@@ -7426,10 +7634,39 @@ def _oracle_open(args):
         webbrowser.open(url)
 
 
+def _oracle_service_cmd(args):
+    """`c3 oracle serve --install | --uninstall | --status` — mirrors `c3 hub`."""
+    from services.oracle_service import OracleService
+    svc = OracleService()
+    port = getattr(args, "port", None) or svc.default_port()
+
+    if getattr(args, "install", False):
+        res = svc.install(port)
+        print(res.get("output", "Service installed."))
+        if res.get("success"):
+            print(f"Oracle will start at login (no terminal window); log: {svc.LOG_FILE}")
+        return
+    if getattr(args, "uninstall", False):
+        res = svc.uninstall()
+        print(res.get("output", "Service uninstalled."))
+        return
+    res = svc.status()
+    print(f"Oracle Service Status ({res.get('platform', 'unknown')}):")
+    print(f"  Installed: {res.get('installed')}")
+    print(f"  Running  : {res.get('running')}")
+    print(f"  Port     : {res.get('port')}  (bind {res.get('bind_host')}, MCP {res.get('mcp_port')})")
+    print(f"  URL      : {res.get('url')}")
+    print(f"  Method   : {res.get('method')}")
+    print(f"  Log      : {res.get('log_path')}")
+
+
 def cmd_oracle(args):
     """Oracle dashboard server + Discovery API key management."""
     sub = getattr(args, "oracle_cmd", None)
     if sub in ("serve", "start"):
+        if any(getattr(args, f, False) for f in ("install", "uninstall", "status")):
+            _oracle_service_cmd(args)
+            return
         # Lazy import: run_oracle builds all Oracle services (matches
         # cmd_hub's deferred-import style so bare `c3` stays fast).
         from oracle.oracle_server import run_oracle

{code_context_control-2.89.1 → code_context_control-2.92.0}/cli/commands/parser.py

@@ -421,9 +421,9 @@ def build_parser(version: str, parse_cli_ide_arg):
     cr_set.add_argument("--stdin", action="store_true", help="Read the value from stdin (piped/multiline values)")
     cr_set.add_argument("--type", dest="ctype",
                         choices=["token", "env", "multiline",
-                                 "address", "identity", "card"],
+                                 "address", "identity", "card", "login"],
                         default="token",
-                        help="Entry type; address/identity/card are structured "
+                        help="Entry type; address/identity/card/login are structured "
                              "(field payload, inject-only, never revealable to the agent)")
     cr_set.add_argument("--desc", default="", help="Human description shown in list/UI")
     cr_set.add_argument("--env-var", default="", help="Env var name used at injection (default: entry name)")
@@ -824,6 +824,13 @@ def build_parser(version: str, parse_cli_ide_arg):
                           help="Server port (default: config 'port', 3331)")
     or_serve.add_argument("--no-browser", action="store_true",
                           help="Don't open the browser")
+    or_serve.add_argument("--install", action="store_true",
+                          help="Register the Oracle as a login/startup service "
+                               "(no terminal window) and start it now")
+    or_serve.add_argument("--uninstall", action="store_true",
+                          help="Remove the Oracle's startup service registration")
+    or_serve.add_argument("--status", action="store_true",
+                          help="Show the Oracle's startup service status")
     or_open = or_subs.add_parser(
         "open",
         help="Sign in to a running dashboard via a single-use URL",

{code_context_control-2.89.1 → code_context_control-2.92.0}/cli/guide/credentials.html

@@ -297,12 +297,14 @@ c3_shell(cmd=<span class="str">'terraform apply'</span>, env_creds=<span class="
 
     <!-- ═══════════════════════════════════ STRUCTURED ═══ -->
     <section id="structured" class="tool-section">
-      <h2>Structured kinds — cards, addresses, identity (v2.87.0)</h2>
+      <h2>Structured kinds — cards, addresses, identity, logins (v2.87.0)</h2>
 
-      <p>Three entry types hold <strong>named fields</strong> instead of one opaque value:
+      <p>Four entry types hold <strong>named fields</strong> instead of one opaque value:
       <code>card</code> (cardholder, number, expiry, optional cvc/billing_zip — Luhn-checked),
-      <code>address</code> (street1, city, state, zip, optional recipient/street2/country/phone) and
-      <code>identity</code> (full_name, optional dob/ssn/phone/email). The payload is stored as one
+      <code>address</code> (street1, city, state, zip, optional recipient/street2/country/phone),
+      <code>identity</code> (full_name, optional dob/ssn/phone/email) and
+      <code>login</code> (site_id, canonical_origin, username, password, optional totp_secret —
+      v2.90.0). The payload is stored as one
       canonical JSON object through the same keyring / encrypted-sidecar path as any other value.</p>
 
       <p>They are <strong>inject-only by construction</strong>, which is stricter than a normal secret:</p>
@@ -315,7 +317,10 @@ c3_shell(cmd=<span class="str">'terraform apply'</span>, env_creds=<span class="
         the field list rather than expanding the whole payload.</li>
         <li><strong>The registry shows a projection, not the data.</strong> Lists and the UI display
         <code>visa ••••4242</code> for a card (brand + last4, deliberately <em>not</em> expiry),
-        city/state for an address, the name for an identity. Field <em>names</em> are public;
+        city/state for an address, the name for an identity, and
+        <code>github · https://github.com · 2FA</code> for a login — site, origin and a 2FA
+        boolean, with the <em>username withheld on purpose</em>, because username + origin is
+        half the credential. Field <em>names</em> are public;
         field <em>values</em> never transit any HTTP response — a sweep test enforces this.</li>
         <li><strong>Echoes redact per field</strong> to <code>[cred:NAME.field]</code>. Caveat: the
         redactor only tracks values of 4+ characters, so a 3-digit CVC or 2-letter state that a
@@ -333,6 +338,18 @@ c3_shell(cmd=<span class="str">'terraform apply'</span>, env_creds=<span class="
       <code>c3 creds get NAME --show</code> (all fields) or <code>--show --field number</code> —
       the browser and the mobile gateway never carry the values, and mobile cannot create
       structured entries at all.</p>
+
+      <p><strong><code>login</code> is storage only, and that is a design constraint, not a
+      gap.</strong> C3 has no browser surface and must not grow one: a login runner in which the
+      <em>agent</em> picks the destination URL turns page-content prompt injection into credential
+      exfiltration, and a check written into a script that already holds the plaintext in its own
+      environment is not a boundary — the script can simply not call it. That is what
+      <code>canonical_origin</code> is for: https-only, stored normalized
+      (<code>scheme://host[:port]</code>, no path/query/fragment/userinfo, host lowercased), so a
+      separate <em>out-of-process</em> runner that the agent does not author can pin a credential to
+      exactly one origin and check the live top-level frame before typing. That runner is
+      deliberately not shipped in this package. <code>totp_secret</code> must be base32 — a
+      malformed seed produces wrong codes that look exactly like a wrong password.</p>
     </section>
 
     <hr class="divider">

{code_context_control-2.89.1 → code_context_control-2.92.0}/cli/guide/oracle.html

@@ -168,9 +168,10 @@
       <div class="step-grid">
         <div class="step-card">
           <span class="step-num">1</span><h4>Start the Oracle</h4>
-          <pre><code>python oracle/oracle_server.py \
-  --no-browser</code></pre>
-          <p style="font-size: 12px; color: var(--text-dim); margin: 8px 0 0;">Prints the REST + MCP URLs and ensures an API key exists. The MCP server starts in a background thread.</p>
+          <pre><code>c3 oracle serve --no-browser
+<span class="com"># or: run it at login, no terminal window</span>
+c3 oracle serve --install</code></pre>
+          <p style="font-size: 12px; color: var(--text-dim); margin: 8px 0 0;">Prints the REST + MCP URLs and ensures an API key exists. The MCP server starts in a background thread. <code>--install</code> registers a windowless background service (Task Scheduler / launchd / systemd) and starts it now — the same buttons live in <strong>Hub → Settings → Oracle service</strong>.</p>
         </div>
         <div class="step-card">
           <span class="step-num">2</span><h4>Get the token</h4>
@@ -325,8 +326,14 @@ curl -X POST \
           <tr><td><code>c3 oracle api key</code></td>    <td>Print just the token (generating one if needed)</td></tr>
           <tr><td><code>c3 oracle api rotate</code></td> <td>Replace the token with a fresh one</td></tr>
           <tr><td><code>c3 oracle api clear</code></td>  <td>Delete the stored token from the keyring</td></tr>
+          <tr><td><code>c3 oracle serve</code></td>      <td>Run the dashboard + discovery endpoints in this terminal (<code>--no-browser</code>, <code>--port</code>)</td></tr>
+          <tr><td><code>c3 oracle serve --install</code></td>   <td>Register the Oracle as a login/startup service — no terminal window — and start it now. Windows: Task Scheduler (Run-key fallback); macOS: launchd; Linux: systemd user unit</td></tr>
+          <tr><td><code>c3 oracle serve --uninstall</code></td> <td>Remove the startup registration (a running Oracle keeps running)</td></tr>
+          <tr><td><code>c3 oracle serve --status</code></td>    <td>Installed? Running? Port, bind host, URL, and the launcher log path</td></tr>
+          <tr><td><code>c3 oracle open</code></td>       <td>Sign in to a running dashboard via a single-use URL (the hub's <strong>Open Oracle</strong> button does the same thing)</td></tr>
         </tbody>
       </table>
+      <p style="font-size: 12px; color: var(--text-dim); margin: 8px 0 0;">The Hub exposes the same controls under <strong>Settings → Oracle service</strong> (Install / Uninstall / Start / Stop / Open). Starting the Oracle from there also fills in the Hub's <em>Oracle URL</em> when it is empty, so the Open Oracle button appears in the top bar. That button opens a <strong>signed-in</strong> dashboard: it redeems the Oracle's owner-only bootstrap key for you. Reaching the dashboard by pasting its URL instead leaves it read-only — the page renders and the header looks healthy, but chat, Save and Test Ollama answer <code>401 unauthorized</code>.</p>
     </section>
 
     <hr class="divider">
@@ -373,6 +380,14 @@ curl -X POST \
             <td><code>The 'keyring' package is required</code></td>
             <td><code>pip install keyring</code> — a C3 dependency that may be missing if you upgraded without re-installing.</td>
           </tr>
+          <tr>
+            <td>Oracle is down after a reboot</td>
+            <td>Nothing restarts a terminal-launched Oracle. Register it once with <code>c3 oracle serve --install</code> (or Hub → Settings → Oracle service → Install); it then starts at login with no window. Startup problems land in <code>~/.c3/oracle/service.log</code> (the launcher) and <code>~/.c3/oracle/oracle.log</code> (the server).</td>
+          </tr>
+          <tr>
+            <td>Installed, but "stopped" right after login</td>
+            <td>If <code>bind_host</code> is a LAN/VPN address, the launcher waits up to 120 s for that address to come up before binding, and Task Scheduler retries a failed start three times a minute apart. Check <code>service.log</code> for <em>waiting for bind host</em>; if the address never appears, the Oracle starts anyway and fails to bind — fix the interface or set <code>bind_host</code> to <code>0.0.0.0</code>.</td>
+          </tr>
         </tbody>
       </table>
     </section>