dotai-cli 0.6.0__tar.gz → 0.7.0__tar.gz

{dotai_cli-0.6.0 → dotai_cli-0.7.0}/.gitignore

@@ -14,3 +14,6 @@ CLAUDE.md
 AGENTS.md
 GEMINI.md
 .dotai-compression-proposal.json
+
+# Local review sessions
+.rdc/

dotai_cli-0.7.0/CHANGELOG.md

@@ -0,0 +1,65 @@
+# Changelog
+
+## Unreleased
+
+## 0.7.0 — 2026-11-04
+
+### Changed
+
+- Share project discovery and override handling between context resolution and
+  primers, including nested directories, custom knowledge paths, and disabled
+  local overrides. Unrelated registered projects are excluded.
+- Deliver full universal rule bodies and freeform conventions in resolved
+  context. Compact primers replace individual scoped-rule listings with a count
+  and resolver pointer.
+- Load active general preferences by default, advertise other active domains,
+  and honor explicitly requested packs independently of domain selection.
+- Preserve complete bodies when loading existing dotai skills while retaining
+  structured Python fields and identifying the source directory.
+- Report file-scope facts separately from resolution status; missing files keep
+  a resolution provisional whenever scoped rules exist.
+
+### Fixed
+
+- Match inherited rule globs from nested working directories and preserve hidden
+  and symlinked file names during matching.
+- Avoid receipt temporary-file collisions and tolerate concurrent history
+  pruning at the retention limit.
+- Pluralize the compact primer's file-scoped rule count.
+- Treat a rule as universal only when every glob is a catch-all, so one
+  specific glob keeps the rule file-scoped.
+- Search, `rules`, project audits, scoped insights, and project skill sync
+  read the same ancestor catalog as context. Unrelated projects stay out.
+
+## 0.6.0 — 2026-07-17
+
+### Added
+
+- `dotai learn --directive` for proactive engineering standards, taste, and
+  guardrails without requiring a prior mistake.
+- `dotai insights` for deterministic local delivery evidence: resolution health,
+  selection counts, last use, rule-summary exposure, and unused knowledge.
+- Bounded metadata-only receipt history, retaining the latest 500 resolutions
+  per agent.
+- `PRODUCT.md` defining dotai as portable engineering judgment for coding agents.
+
+### Changed
+
+- Repositioned the CLI and documentation around developer-controlled engineering
+  judgment rather than universal context.
+- `dotai sync` now has one repository-safe behavior: local context outside the
+  worktree.
+- `dotai primer` now always emits the compact bootstrap.
+- `dotai search` reads live knowledge instead of a cached index.
+- `dotai install` is the single entry point for supported external skill formats.
+
+### Removed
+
+- Commands: `watch`, `detach`, `index`, `tree`, `prompt`, `role`, `convert`, and
+  `import-plugin`.
+- Shared/full/agent-specific sync controls and primer session overlays.
+- Freeform `dotai learn --append-md` capture.
+- The cached knowledge-tree model and `watchdog` dependency.
+
+This release intentionally breaks pre-1.0 CLI compatibility to keep one clear,
+local-first product path.

{dotai_cli-0.6.0 → dotai_cli-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: dotai-cli
-Version: 0.6.0
+Version: 0.7.0
 Summary: Portable engineering judgment for coding agents
 Project-URL: Homepage, https://github.com/dawalama/dotai
 Project-URL: Repository, https://github.com/dawalama/dotai
@@ -150,7 +150,7 @@ dotai sync
 
 Local context storage does not, by itself, make an agent load the context. Until an agent adapter is configured, use `dotai primer --path .` to print a compact bootstrap for pasting or piping into your agent.
 
-dotai uses progressive disclosure to keep prompts small. Synced context contains rule summaries and role/skill catalogs. Expand only what a task needs:
+dotai uses progressive disclosure to keep prompts small. Compact primers include complete universal directives, a count of file-scoped rules, and role/skill catalogs. Unrelated scoped rules are not listed individually. Expand what a task needs:
 
 ```bash
 # Expand rules matching the affected files
@@ -165,6 +165,26 @@ dotai context --path . --skill run_review
 
 Selection is deterministic: file globs, explicit context tags, active preference domains, and named skills or roles. dotai does not guess from semantic similarity. Every expanded item includes the reason it was selected.
 
+`context` and `primer` share the same scoped catalog. Within a Git worktree,
+dotai loads global knowledge and applicable ancestor knowledge directories down
+to the invocation directory, honoring registered custom `ai_dir` paths. Outside
+Git, discovery stops at the nearest registered project, or uses only the supplied
+directory when it is unregistered. Unrelated registered projects are not read.
+Local definitions override inherited items with the same ID; a disabled local
+rule masks the inherited definition. A project's `disabled_rules` list excludes
+global definitions while allowing explicit local replacements.
+
+Affected files are relative to `--path` (absolute paths also work). Project rule
+globs are relative to the directory owning that project's knowledge; global
+globs use the repository or project root. Matching uses logical file paths,
+including symlink names. The host remains responsible for filesystem permissions.
+
+The resolver includes complete universal rule bodies and applicable `rules.md`
+notes. Active `general` preference packs load by default. Other active domains
+are listed without their bodies; select one with `--domain cli`, or load a named
+pack directly with `--with-prefs <id>` regardless of its domain. Explicit packs
+remain subject to scope and enabled state.
+
 ### Automatic delivery with Claude Code
 
 The resolver is infrastructure; you should not have to type `dotai context`
@@ -190,11 +210,11 @@ dotai context for substantial development work, after affected files are known,
 and to avoid repeated calls when the task has not changed. Repository and
 organization instructions remain authoritative.
 
-For file-sensitive workflows such as review, debugging, verification, scaffolding,
-maintenance, and release work, a resolution without `--files` is explicitly
+When file-scoped rules exist, or a selected workflow requires files, a resolution without `--files` is explicitly
 marked provisional. Claude must resolve again after discovering the affected
 files. `dotai agent last claude` reports whether the latest resolution is
-`provisional` or `complete`.
+`provisional` or `resolved`, and whether file scope was provided or remains
+unknown. Supplied files do not prove that every affected file was discovered.
 
 The adapter does not modify repositories, install a persistent process, or use
 MCP. Existing personal Claude instructions are preserved. To remove only
@@ -225,7 +245,7 @@ dotai insights --json
 ```
 
 The report shows complete versus provisional resolutions, selection counts,
-last-selected timestamps, universal rule-summary exposure, and enabled items
+last-selected timestamps, universal-rule exposure, and enabled items
 that have never been selected in the current window. Selection proves delivery,
 not compliance: dotai cannot claim that an agent followed an instruction merely
 because it received it.
@@ -448,6 +468,10 @@ Hard rules always take precedence if they conflict.
 
 ### Searching your knowledge
 
+Search reads the same scoped catalog as `dotai context`. From a project, it
+includes global knowledge and applicable ancestor directories, and it skips
+unrelated registered projects. Pass `--path` to search another directory.
+
 ```bash
 # Search by keyword
 dotai search "useEffect"
@@ -590,9 +614,16 @@ Analyze the current branch's diff for issues that tests don't catch.
 4. Generate a structured report with file:line references
 ```
 
+When loading existing dotai skill files, dotai preserves the complete Markdown
+body for execution, including custom sections, nested steps, and code blocks.
+Extracted fields remain available to Python consumers; rendering uses the
+preserved body and identifies the source directory for relative resources.
+Native-format import still uses the existing converter; migration to native
+`SKILL.md` packages and preservation of host-specific metadata are separate work.
+
 ### Gotchas
 
-Skills should document **common failure points** — things that push the agent out of its normal way of thinking. Gotchas are rendered with warning markers in the agent prompt so they get extra attention.
+Skills should document **common failure points** — things that push the agent out of its normal way of thinking. Gotchas in the Markdown body remain verbatim. Frontmatter gotchas and programmatically constructed gotcha fields are rendered with warning markers.
 
 ### Conditional Contexts
 
@@ -712,13 +743,14 @@ dotai toggle no-useeffect --off --project my-legacy-app
 dotai toggle no-useeffect --on
 ```
 
-Synced local context contains a compact bootstrap: universal rule summaries plus preference, role, and skill catalogs. Use `dotai context` to expand relevant material on demand.
+Synced local context contains a compact bootstrap: full universal directives, a scoped-rule count, and preference, role, and skill catalogs. Use `dotai context` to expand relevant material on demand.
 
 ## Agent Sync
 
 `dotai sync` prepares repository-safe local context with:
 
-- **Universal structured rule summaries** (always visible)
+- **Complete universal structured directives** (always visible)
+- **A count and resolver pointer for file-scoped rules**
 - **Pointers to freeform `rules.md` conventions**
 - **Role and skill catalogs** (names, triggers, categories — not full workflows)
 Context is always written outside the worktree. Team instructions take precedence over personal dotai rules and preferences. dotai does not attempt unreliable keyword-based conflict resolution; the generated context tells the agent to ignore conflicting personal guidance and ask when a disagreement is ambiguous.
@@ -855,7 +887,7 @@ dotai install <source> [-s skill]      # Install skills from git repo or local p
 dotai install --update [-s skill] [--skip-vet]  # Vetted refresh from recorded sources
 dotai remove <skill> [-p project]     # Remove an installed skill
 dotai new-skill <name> [-t trigger]    # Create a new skill from template
-dotai search "query" [--type t] [--tag] # Search live knowledge
+dotai search "query" [--type t] [--tag] [--path .] # Search knowledge for a directory
 ```
 
 ## Philosophy

{dotai_cli-0.6.0 → dotai_cli-0.7.0}/README.md

@@ -122,7 +122,7 @@ dotai sync
 
 Local context storage does not, by itself, make an agent load the context. Until an agent adapter is configured, use `dotai primer --path .` to print a compact bootstrap for pasting or piping into your agent.
 
-dotai uses progressive disclosure to keep prompts small. Synced context contains rule summaries and role/skill catalogs. Expand only what a task needs:
+dotai uses progressive disclosure to keep prompts small. Compact primers include complete universal directives, a count of file-scoped rules, and role/skill catalogs. Unrelated scoped rules are not listed individually. Expand what a task needs:
 
 ```bash
 # Expand rules matching the affected files
@@ -137,6 +137,26 @@ dotai context --path . --skill run_review
 
 Selection is deterministic: file globs, explicit context tags, active preference domains, and named skills or roles. dotai does not guess from semantic similarity. Every expanded item includes the reason it was selected.
 
+`context` and `primer` share the same scoped catalog. Within a Git worktree,
+dotai loads global knowledge and applicable ancestor knowledge directories down
+to the invocation directory, honoring registered custom `ai_dir` paths. Outside
+Git, discovery stops at the nearest registered project, or uses only the supplied
+directory when it is unregistered. Unrelated registered projects are not read.
+Local definitions override inherited items with the same ID; a disabled local
+rule masks the inherited definition. A project's `disabled_rules` list excludes
+global definitions while allowing explicit local replacements.
+
+Affected files are relative to `--path` (absolute paths also work). Project rule
+globs are relative to the directory owning that project's knowledge; global
+globs use the repository or project root. Matching uses logical file paths,
+including symlink names. The host remains responsible for filesystem permissions.
+
+The resolver includes complete universal rule bodies and applicable `rules.md`
+notes. Active `general` preference packs load by default. Other active domains
+are listed without their bodies; select one with `--domain cli`, or load a named
+pack directly with `--with-prefs <id>` regardless of its domain. Explicit packs
+remain subject to scope and enabled state.
+
 ### Automatic delivery with Claude Code
 
 The resolver is infrastructure; you should not have to type `dotai context`
@@ -162,11 +182,11 @@ dotai context for substantial development work, after affected files are known,
 and to avoid repeated calls when the task has not changed. Repository and
 organization instructions remain authoritative.
 
-For file-sensitive workflows such as review, debugging, verification, scaffolding,
-maintenance, and release work, a resolution without `--files` is explicitly
+When file-scoped rules exist, or a selected workflow requires files, a resolution without `--files` is explicitly
 marked provisional. Claude must resolve again after discovering the affected
 files. `dotai agent last claude` reports whether the latest resolution is
-`provisional` or `complete`.
+`provisional` or `resolved`, and whether file scope was provided or remains
+unknown. Supplied files do not prove that every affected file was discovered.
 
 The adapter does not modify repositories, install a persistent process, or use
 MCP. Existing personal Claude instructions are preserved. To remove only
@@ -197,7 +217,7 @@ dotai insights --json
 ```
 
 The report shows complete versus provisional resolutions, selection counts,
-last-selected timestamps, universal rule-summary exposure, and enabled items
+last-selected timestamps, universal-rule exposure, and enabled items
 that have never been selected in the current window. Selection proves delivery,
 not compliance: dotai cannot claim that an agent followed an instruction merely
 because it received it.
@@ -420,6 +440,10 @@ Hard rules always take precedence if they conflict.
 
 ### Searching your knowledge
 
+Search reads the same scoped catalog as `dotai context`. From a project, it
+includes global knowledge and applicable ancestor directories, and it skips
+unrelated registered projects. Pass `--path` to search another directory.
+
 ```bash
 # Search by keyword
 dotai search "useEffect"
@@ -562,9 +586,16 @@ Analyze the current branch's diff for issues that tests don't catch.
 4. Generate a structured report with file:line references
 ```
 
+When loading existing dotai skill files, dotai preserves the complete Markdown
+body for execution, including custom sections, nested steps, and code blocks.
+Extracted fields remain available to Python consumers; rendering uses the
+preserved body and identifies the source directory for relative resources.
+Native-format import still uses the existing converter; migration to native
+`SKILL.md` packages and preservation of host-specific metadata are separate work.
+
 ### Gotchas
 
-Skills should document **common failure points** — things that push the agent out of its normal way of thinking. Gotchas are rendered with warning markers in the agent prompt so they get extra attention.
+Skills should document **common failure points** — things that push the agent out of its normal way of thinking. Gotchas in the Markdown body remain verbatim. Frontmatter gotchas and programmatically constructed gotcha fields are rendered with warning markers.
 
 ### Conditional Contexts
 
@@ -684,13 +715,14 @@ dotai toggle no-useeffect --off --project my-legacy-app
 dotai toggle no-useeffect --on
 ```
 
-Synced local context contains a compact bootstrap: universal rule summaries plus preference, role, and skill catalogs. Use `dotai context` to expand relevant material on demand.
+Synced local context contains a compact bootstrap: full universal directives, a scoped-rule count, and preference, role, and skill catalogs. Use `dotai context` to expand relevant material on demand.
 
 ## Agent Sync
 
 `dotai sync` prepares repository-safe local context with:
 
-- **Universal structured rule summaries** (always visible)
+- **Complete universal structured directives** (always visible)
+- **A count and resolver pointer for file-scoped rules**
 - **Pointers to freeform `rules.md` conventions**
 - **Role and skill catalogs** (names, triggers, categories — not full workflows)
 Context is always written outside the worktree. Team instructions take precedence over personal dotai rules and preferences. dotai does not attempt unreliable keyword-based conflict resolution; the generated context tells the agent to ignore conflicting personal guidance and ask when a disagreement is ambiguous.
@@ -827,7 +859,7 @@ dotai install <source> [-s skill]      # Install skills from git repo or local p
 dotai install --update [-s skill] [--skip-vet]  # Vetted refresh from recorded sources
 dotai remove <skill> [-p project]     # Remove an installed skill
 dotai new-skill <name> [-t trigger]    # Create a new skill from template
-dotai search "query" [--type t] [--tag] # Search live knowledge
+dotai search "query" [--type t] [--tag] [--path .] # Search knowledge for a directory
 ```
 
 ## Philosophy

{dotai_cli-0.6.0 → dotai_cli-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "dotai-cli"
-version = "0.6.0"
+version = "0.7.0"
 description = "Portable engineering judgment for coding agents"
 readme = "README.md"
 license = "MIT"

{dotai_cli-0.6.0 → dotai_cli-0.7.0}/src/dotai/__init__.py

@@ -1,3 +1,3 @@
 """dotai — Portable engineering judgment for coding agents."""
 
-__version__ = "0.6.0"
+__version__ = "0.7.0"

{dotai_cli-0.6.0 → dotai_cli-0.7.0}/src/dotai/agents.py

@@ -30,6 +30,10 @@ resolution replaces the provisional one and loads file-scoped rules. Do not call
 dotai for casual conversation, simple factual questions, or repeatedly after a
 complete file-aware resolution unless the task or affected files materially change.
 
+The result lists active preference domains that were not loaded. Add
+`--domain <relevant domain>` when one applies, or `--with-prefs <id>` when the user
+requests a specific pack. Active general preferences load by default.
+
 When the user explicitly invokes a dotai workflow such as `/run_review`, load it
 with `{command} context --agent claude --path . --skill run_review`. Treat dotai preferences as soft
 taste only; team rules, security constraints, and user instructions take precedence.

dotai_cli-0.7.0/src/dotai/catalog.py

@@ -0,0 +1,67 @@
+"""One scoped view of knowledge for context resolution and exports."""
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from .models import GlobalConfig, PreferencePack, Role, Rule, Skill
+from .preferences import load_active_pack_ids, load_preferences_from_dir
+from .roles import load_roles_from_dir
+from .rules import load_rules_from_dir, load_rules_md
+from .scope import KnowledgeScope, resolve_scope
+from .skills import load_skills_from_dir
+
+
+@dataclass(frozen=True)
+class FreeformNote:
+    scope: str
+    path: Path
+    body: str
+
+
+@dataclass
+class KnowledgeCatalog:
+    scope: KnowledgeScope
+    rules: list[Rule]
+    skills: list[Skill]
+    roles: list[Role]
+    preferences: list[PreferencePack]
+    notes: list[FreeformNote]
+    rule_roots: dict[str, Path | None]
+
+
+def load_catalog(
+    config: GlobalConfig,
+    project_name: str | None = None,
+    project_path: Path | None = None,
+    extra_prefs: list[str] | None = None,
+) -> KnowledgeCatalog:
+    scope = resolve_scope(config, project_name, project_path)
+    rules: dict[str, Rule] = {}
+    skills: dict[str, Skill] = {}
+    roles: dict[str, Role] = {}
+    preferences: dict[str, PreferencePack] = {}
+    notes: list[FreeformNote] = []
+    rule_roots: dict[str, Path | None] = {}
+    for entry in scope.directories:
+        label, directory = entry.scope, entry.path
+        for rule in load_rules_from_dir(directory / "rules", label):
+            if directory != scope.directories[0].path or rule.id not in scope.disabled_rules:
+                rules[rule.id] = rule
+                rule_roots[rule.id] = entry.root_path
+        skills.update((s.id, s) for s in load_skills_from_dir(directory / "skills", label))
+        roles.update((r.id, r) for r in load_roles_from_dir(directory / "roles", label))
+        preferences.update((p.id, p) for p in load_preferences_from_dir(directory / "preferences", label))
+        body = load_rules_md(directory)
+        if body:
+            notes.append(FreeformNote(label, directory / "rules.md", body))
+
+    active = list(extra_prefs or [])
+    for entry in reversed(scope.directories):
+        active.extend(load_active_pack_ids(entry.path))
+    active = list(dict.fromkeys(active))
+    return KnowledgeCatalog(
+        scope, [r for r in rules.values() if r.enabled], list(skills.values()),
+        list(roles.values()),
+        [preferences[i] for i in active if i in preferences and preferences[i].enabled],
+        notes, rule_roots,
+    )

{dotai_cli-0.6.0 → dotai_cli-0.7.0}/src/dotai/cli/agents_cmd.py

@@ -53,8 +53,9 @@ def agent(
         console.print(f"  Project: {receipt.get('project_path', 'unknown')}")
         console.print(f"  Task: {receipt.get('task') or 'not provided'}")
         provisional = bool(receipt.get("provisional"))
-        console.print(f"  Resolution: {'provisional' if provisional else 'complete'}")
+        console.print(f"  Resolution: {'provisional' if provisional else 'resolved'}")
         files = receipt.get("files") or []
+        console.print(f"  File scope: {'provided' if files else 'unknown'}")
         console.print(f"  Files: {', '.join(files) if files else 'not known'}")
         console.print(f"  Skill: {receipt.get('skill') or 'none'}")
         console.print(f"  Role: {receipt.get('role') or 'none'}")

{dotai_cli-0.6.0 → dotai_cli-0.7.0}/src/dotai/cli/rules_cmd.py

@@ -270,14 +270,19 @@ def rules(
     all: bool = typer.Option(False, "--all", "-a", help="Show all rules including disabled"),
     check: bool = typer.Option(False, "--check", help="Scan for duplicates, empty bodies, weak descriptions"),
 ):
-    """List rules. Shows resolved active rules by default.
+    """List rules. Shows the active rules for this directory by default.
 
-    Use --check to audit rule quality (duplicates, empty bodies).
+    Use --project to resolve a registered project, or --all for every rule in
+    the library. Use --check to audit rule quality (duplicates, empty bodies).
     """
+    from ..catalog import load_catalog
     from ..store import load_config
     from ..rules import load_all_rules, resolve_rules_for_project, check_rule_quality
 
     config = load_config()
+    if project and not config.get_project(project):
+        console.print(f"[red]Project '{project}' not found[/red]")
+        raise typer.Exit(2)
 
     if check:
         findings = check_rule_quality(config)
@@ -303,7 +308,7 @@ def rules(
     elif project:
         rule_list = resolve_rules_for_project(config, project)
     else:
-        rule_list = load_all_rules(config)
+        rule_list = load_catalog(config, project_path=Path.cwd()).rules
 
     if not rule_list:
         console.print("[dim]No rules found. Use `dotai learn` to add rules.[/dim]")

{dotai_cli-0.6.0 → dotai_cli-0.7.0}/src/dotai/cli/sync_cmd.py

@@ -22,10 +22,6 @@ def sync(
     config = load_config()
     project_path = Path(path).expanduser().resolve()
 
-    # Find project name
-    project_config = next((p for p in config.projects if p.path == project_path), None)
-    project_name = project_config.name if project_config else None
-
     plan = plan_sync(project_path, get_config_dir())
 
     console.print(f"Mode: [bold]{plan.mode}[/bold]")
@@ -36,7 +32,7 @@ def sync(
     if check:
         return
 
-    written = sync_local_context(plan, config, project_name)
+    written = sync_local_context(plan, config)
 
     for f in written:
         console.print(f"  [green]Synced[/green] {f}")
@@ -53,14 +49,13 @@ def primer(
 
     config = load_config()
     project_path = Path(path).expanduser().resolve() if path else None
-    if project_path:
-        matched = next((p for p in config.projects if p.path == project_path), None)
-        if matched:
-            project = matched.name
-    typer.echo(generate_primer(
-        config, project, project_path=project_path,
-        compact=True,
-    ))
+    try:
+        typer.echo(generate_primer(
+            config, project, project_path=project_path, compact=True,
+        ))
+    except ValueError as error:
+        console.print(f"[red]{error}[/red]")
+        raise typer.Exit(2) from error
 
 
 @app.command("context")
@@ -88,13 +83,10 @@ def resolve_task_context(
 
     config = load_config()
     project_path = Path(path).expanduser().resolve()
-    matched = next((p for p in config.projects if p.path == project_path), None)
-    project_name = matched.name if matched else None
     try:
         resolved = resolve_context(
             config,
             project_path,
-            project_name,
             task=task,
             files=split(files),
             contexts=split(contexts),
@@ -130,19 +122,21 @@ def search(
     query: str = typer.Argument("", help="Search keyword (optional if using --tag)"),
     type: Optional[str] = typer.Option(None, "--type", "-t", help="Filter by rule, preference, role, or skill"),
     tag: Optional[str] = typer.Option(None, "--tag", help="Filter by tag"),
+    path: str = typer.Option(".", "--path", help="Search the knowledge that applies to this directory"),
 ):
-    """Search live dotai knowledge by keyword, type, or tag.
+    """Search the knowledge that applies to a directory.
+
+    Uses the same ancestor catalog as context and primer. Unrelated registered
+    projects are not read. Active preference packs are included; inactive packs
+    stay out.
 
     Examples:
       dotai search "useEffect"
       dotai search "review" --type skill
       dotai search --tag security
-      dotai search "auth" --type rule --tag react
+      dotai search "auth" --type rule --tag react --path .
     """
-    from ..preferences import load_all_preferences
-    from ..roles import load_all_roles
-    from ..rules import load_all_rules
-    from ..skills import load_all_skills
+    from ..catalog import load_catalog
     from ..store import load_config
 
     valid_types = {"rule", "preference", "role", "skill"}
@@ -153,11 +147,16 @@ def search(
         raise typer.Exit(1)
 
     config = load_config()
+    try:
+        catalog = load_catalog(config, project_path=Path(path).expanduser().resolve())
+    except ValueError as error:
+        console.print(f"[red]{error}[/red]")
+        raise typer.Exit(2) from error
     items = []
-    items.extend(("rule", item.id, item.description, item.tags, item.file_path) for item in load_all_rules(config))
-    items.extend(("preference", item.id, item.description, item.tags, item.file_path) for item in load_all_preferences(config))
-    items.extend(("role", item.id, item.description, item.tags, item.file_path) for item in load_all_roles(config))
-    items.extend(("skill", item.id, item.description, item.tags, item.file_path) for item in load_all_skills(config))
+    items.extend(("rule", item.id, item.description, item.tags, item.file_path) for item in catalog.rules)
+    items.extend(("preference", item.id, item.description, item.tags, item.file_path) for item in catalog.preferences)
+    items.extend(("role", item.id, item.description, item.tags, item.file_path) for item in catalog.roles)
+    items.extend(("skill", item.id, item.description, item.tags, item.file_path) for item in catalog.skills)
 
     query_lower = query.strip().lower()
     tag_lower = tag.strip().lower() if tag else None