architext 0.2.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f01f07f6d9ef1e104d4c8f5dc9575faf85864ec4a16e26e9776033e6bfb9c0df
-  data.tar.gz: 9b3abb2535fe6d4145173a2b6d4a8dfb9d4857f5dba6f13e3d0dd484e67ac15f
+  metadata.gz: 98ba60f856ccd4030ef1c0bbedc1cdef3ee2e1cb4fbfd2bbbf6208c0360123a3
+  data.tar.gz: 2fd7551d931e0a96a700cd78df0b9ed88cc301fb209ad09a2f32b3cfea504976
 SHA512:
-  metadata.gz: ba45236c8562e14652ff0b1404e5ca44b6b1f485f11fd23d288bac35a61260437abd4fc72e13f95e0e91385ca95d6342912ad14a7c9730ee80ba6d11f1271458
-  data.tar.gz: 91a02ffeb556817e1161e3560885591a7cf917f92e7e0ff8e11c99ab8f823e0c2889cc80ec4a853b083473c0691af7056265d8b2d37824918294146b07f5fa7b
+  metadata.gz: f4f6c4be6b57fa857338eb2abbab2208d16e011cda8cc47313fd6b9c55beb906cec5a57dc4f8396406a9a635471c22076366b2c1ec98db2af428954c83c6aa0a
+  data.tar.gz: 774bb942a60538631c6561947dd4bd282d787d2558f8a8b158a441bfabfd5854dcc1b2401cbf3cd3890e8d2f2ee8076a08e865f687d9dd53f349d73a771b53fd

data/CHANGELOG.md

@@ -3,7 +3,19 @@
 All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v1.0.0.html).
+
+## [1.0.0] - 2026-05-29
+
+### Added
+- Native markdown folder source is now the default, searching `.md` and `.markdown` files under the current directory or `--root`.
+- `--source native|obsidian` and `--root PATH` flags for explicit source selection.
+- Native search support for plain terms, quoted phrases, `tag:`, `path:`, and `file:` query tokens.
+
+### Changed
+- Obsidian CLI integration is now optional and explicit via `--source obsidian` or legacy `--vault`.
+- TUI and diagnostics now use source/root language and only show Obsidian CLI details in Obsidian mode.
+- README and gem metadata now position ARCHiTEXT as a markdown context stitching tool.
 
 ## [0.2.0] - 2026-05-16
 

data/README.md

@@ -3,7 +3,7 @@
 <p align="center">
   <img src="assets/logo.svg" alt="ARCHiTEXT Logo" width="200">
   <br>
-  <b>The bridge between your Obsidian vault and LLMs.</b>
+  <b>The bridge between markdown notes and LLMs.</b>
   <br>
   <i>A high-performance Ruby TUI for context stitching.</i>
 </p>
@@ -12,20 +12,42 @@
   <a href="https://github.com/CanPixel/ARCHiTEXT/actions/workflows/ci.yml">
     <img src="https://github.com/CanPixel/ARCHiTEXT/actions/workflows/ci.yml/badge.svg" alt="CI Status">
   </a>
+  <img src="https://img.shields.io/badge/maintained-yes-green.svg" alt="Maintained">
+  <a href="https://clickgems.clickhouse.com/dashboard/architext">
+    <img src="https://img.shields.io/gem/dt/architext" alt="RubyGem Downloads">
+  </a>
+  <a href="https://rubygems.org/gems/architext">
+    <img src="https://img.shields.io/github/stars/CanPixel" alt="GitHub Stars">
+  </a>
+</p>
+
+<p align="center">
+  <img src="https://img.shields.io/badge/Ruby-CC342D?style=flat&logo=ruby&logoColor=white" alt="Ruby">
   <a href="https://rubygems.org/gems/architext">
-    <img src="https://img.shields.io/badge/version-v0.2.0-5BE8B8.svg" alt="Version 0.2.0">
+    <img src="https://img.shields.io/gem/v/architext" alt="License">
+  </a>
+  <a href="https://rubygems.org/gems/architext">
+    <img src="https://img.shields.io/badge/version-v1.0.0-5BE8B8.svg" alt="Version 1.0.0">
   </a>
   <a href="LICENSE">
     <img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="License">
   </a>
-  <img src="https://img.shields.io/badge/maintained-yes-green.svg" alt="Maintained">
 </p>
 
 ---
 
+<img src="assets/title.svg" alt="ARCHiTEXT Text Logo">
+
 <img src="assets/social-preview.svg" alt="ARCHiTEXT Social Preview" width="1080">
 
-`ARCHiTEXT` is a standalone Ruby TUI for stitching Obsidian notes into an LLM-friendly Markdown context bundle. It uses the official `obsidian` CLI as the source of truth for vault search and file reads, providing a visual terminal interface for selecting notes.
+
+As LLM context windows grow, the way we feed them data **needs to scale**.
+
+Modern AI agents thrive on context, but gathering that context manually from sprawling markdown folders is tedious. ARCHiTEXT transforms this process into a seamless, visual experience. It allows you to search, filter, and "stitch" multiple notes into a single, structured Markdown bundle that agents can consume immediately.
+
+# Welcome to ARCHiTEXT!
+
+`ARCHiTEXT` is a standalone Ruby TUI for stitching markdown notes into an LLM-friendly context bundle. By default it searches the current folder recursively for `.md` and `.markdown` files, while still offering an optional Obsidian CLI source for users who want vault-name resolution.
 
 ## 🚀 Quick Start
 
@@ -34,7 +56,7 @@
 architext
 ```
 
-ARCHiTEXT will detect your active Obsidian vault, ask for a search query, then open a picker where you can select notes and copy the stitched context bundle to your clipboard.
+ARCHiTEXT will search markdown files in the current folder, ask for a search query, then open a picker where you can select notes and copy the stitched context bundle to your clipboard.
 
 Common next steps:
 
@@ -42,17 +64,21 @@ Common next steps:
 # Search with a specific query
 architext --query "game"
 
-# Search a specific vault
-architext --vault "Main Vault" --query "project"
+# Search a specific folder
+architext --root ~/Notes --query "project"
 
 # Print the bundle instead of copying it
 architext --query "tag:#project/active" --all --stdout
+
+# Use Obsidian CLI mode explicitly
+architext --source obsidian --vault "Main Vault" --query "Ideas"
 ```
 
 ## ✨ Features
 
 - **Visual Picker:** Interactively select notes using a high-performance ANSI TUI.
-- **Vault-Aware UX:** Active vault is always visible in the TUI, with inline vault switching.
+- **Source-Aware UX:** Active folder or Obsidian vault is always visible in the TUI, with inline source switching.
+- **Native Markdown Search:** Search any folder containing `.md` or `.markdown` files without opening Obsidian.
 - **Context Stitching:** Automatically bundles selected notes into a single Markdown file.
 - **LLM Ready:** Output is formatted specifically for easy consumption by AI agents.
 - **No Dependencies:** Built-in ANSI-based TUI logic (no complex visual gems required).
@@ -65,6 +91,11 @@ architext --query "tag:#project/active" --all --stdout
 ```sh
 gem install architext
 architext --version
+```
+
+### Uninstall
+
+```sh
 gem uninstall architext
 ```
 
@@ -81,7 +112,9 @@ gem install ./architext-*.gem
 
 ## ⚙️ Configuration
 
-Architext relies on the [Obsidian CLI](https://github.com/obsidianmd/obsidian-cli). Ensure it is installed and available on your `PATH`.
+Architext does not require Obsidian for normal use. Native mode searches markdown files directly under the current folder or a folder passed with `--root`.
+
+Obsidian CLI integration remains available as an optional source. Use it when you want Obsidian vault-name or vault-id resolution.
 
 ### Supported Platforms
 
@@ -89,9 +122,9 @@ Architext relies on the [Obsidian CLI](https://github.com/obsidianmd/obsidian-cl
 - **Windows:** Native terminal support (PowerShell/Windows Terminal) with `clip` clipboard integration.
 - **Linux:** Native terminal support with clipboard integration via `wl-copy`, `xclip`, or `xsel`.
 
-### Setting the Obsidian CLI Path
+### Optional Obsidian CLI Path
 
-If the CLI is not in your `PATH`, you can set the `ARCHITEXT_OBSIDIAN` environment variable:
+If you use `--source obsidian` and the CLI is not in your `PATH`, set the `ARCHITEXT_OBSIDIAN` environment variable:
 
 ```sh
 export ARCHITEXT_OBSIDIAN="/path/to/obsidian"
@@ -112,45 +145,60 @@ architext
 # Search with a specific query
 architext --query "Zombie Parkour"
 
+# Search a specific markdown folder
+architext --root ~/Notes --query "project"
+
 # Output directly to stdout (useful for piping)
-architext --query "tag:#ctx/current" --stdout | gemini "Summarize this"
+architext --query "tag:#ctx/current" --all --stdout | gemini "Summarize this"
+
+# Use Obsidian CLI mode with a specific vault
+architext --source obsidian --vault "Main Vault" --query "Ideas"
 
-# Specify a vault
+# Legacy shorthand: --vault implies --source obsidian
 architext --vault "Main Vault" --query "Ideas"
 
-# Set a persistent default vault
+# Set a persistent default Obsidian vault
 architext --set-default-vault "Main Vault"
 
-# Clear the persistent default vault
+# Clear the persistent default Obsidian vault
 architext --clear-default-vault
 
 # Check exactly which executable version is running
 architext --version
 
-# Print vault/CLI diagnostics before searching
+# Print source diagnostics before searching
 architext --diagnose
 
 # Skip the picker and include all results
 architext --query "tag:#project/active" --all --stdout
 ```
 
-### Vault Selection Behavior
+### Source Selection Behavior
+
+- Native mode is the default and uses the current working directory as the markdown root.
+- `--root PATH` sets the native markdown root for the current run.
+- `--source native|obsidian` chooses the source explicitly.
+- `--vault` sets the Obsidian vault only for the current run and implies `--source obsidian`.
+- `--set-default-vault` stores a persistent default vault for future Obsidian-mode runs.
+- At the search prompt, type `v` to open source configuration mode.
+- Press `v` in the TUI selection screen to change source inline for the current session.
+- Startup diagnostics show native root and markdown file count, or Obsidian CLI details when Obsidian mode is active.
 
-- `--vault` sets the vault only for the current run.
-- `--set-default-vault` stores a persistent default vault for future runs.
-- If `--vault` is omitted, the persistent default vault is used when available.
-- At the search prompt, type `v` to open vault configuration mode.
-- Press `v` in the TUI selection screen to change vault inline for the current session.
-- The active vault is shown in the TUI header (`vault: ...`) so target scope is always visible.
-- Vault path resolution is performed by the Obsidian CLI (`vault=<name_or_id>`); ARCHiTEXT displays the vault reference and source.
-- Startup prompt includes an Obsidian connection check (`version`, resolved vault summary, executable path).
+### Native Search Syntax
+
+- Empty query lists all markdown files under the active root.
+- Plain terms match case-insensitively against relative paths or file content.
+- Quoted phrases match literally.
+- `tag:foo` and `tag:#foo` match markdown tags such as `#foo` and nested tags such as `#foo/bar`.
+- `path:term` and `file:term` match relative paths.
+- Multiple tokens are AND-matched.
 
 ### Search Prompt Controls
 
 | Input | Action |
 | --- | --- |
 | `enter` | Run search with default query |
-| `v` | Open vault configuration screen |
+| `v` | Open source configuration screen |
 | `q` | Quit |
 
 ### TUI Controls
@@ -161,27 +209,36 @@ architext --query "tag:#project/active" --all --stdout
 | `space` | Toggle selection for current note |
 | `a` | Toggle all visible notes |
 | `/` | Filter current results |
-| `n` | Start a new Obsidian search |
-| `v` | Set/change active vault |
+| `n` | Start a new markdown search |
+| `v` | Set/change active source |
 | `enter` | Confirm and bundle selected notes |
 | `q` | Return to search prompt |
 
 ## 🔍 Troubleshooting
 
 ### Obsidian CLI Not Found
-If you see an error about `obsidian` command not found:
+This only applies when running with `--source obsidian` or `--vault`. If you see an error about `obsidian` command not found:
 1. Ensure the Obsidian desktop app is installed.
 2. Verify that you have installed the `obsidian` CLI tool.
 3. Check if `obsidian` is in your `PATH` by running `which obsidian` (macOS/Linux) or `where obsidian` (Windows).
 4. If you previously exported `OBSCTX_OBSIDIAN`, rename it to `ARCHITEXT_OBSIDIAN`.
 
+### Command Not Found After Gem Install
+If `gem install architext` succeeds but `architext` is not found, your Ruby executable directory is not on your shell `PATH`.
+
+1. Find RubyGems executable directory:
+   - `gem env | grep "EXECUTABLE DIRECTORY"`
+2. Add that directory to your shell `PATH` (for `zsh`, update `~/.zshrc`).
+3. Restart your shell and verify:
+   - `which architext`
+   - `architext --version`
+
 ### No Results But Notes Exist
-- Verify the active vault shown in the TUI header.
-- At the search prompt, type `v` to open vault configuration.
-- In selection, use `v` to switch vault and rerun the query.
-- Set a persistent vault with `--set-default-vault "Your Vault"`.
-- For one-off runs, pass `--vault "Your Vault"` explicitly.
-- Run `architext --diagnose` to print the exact vault reference/source and Obsidian CLI resolution before searching.
+- Verify the active source shown in the TUI header.
+- In native mode, confirm the current folder or `--root` contains markdown files.
+- At the search prompt, type `v` to open source configuration.
+- In selection, use `v` to switch root or Obsidian vault and rerun the query.
+- Run `architext --diagnose` to print the active source, native root, markdown count, and Obsidian details when applicable.
 
 ### Clipboard Issues
 Architext auto-detects clipboard tools:

data/lib/architext/cli.rb

@@ -2,13 +2,13 @@
 
 require 'io/console'
 require 'optparse'
-require 'shellwords'
 
 require_relative 'bundle'
 require_relative 'clipboard'
 require_relative 'obsidian'
 require_relative 'picker'
 require_relative 'settings'
+require_relative 'sources'
 require_relative 'tui'
 require_relative 'version'
 
@@ -16,10 +16,15 @@ module Architext
   # rubocop:disable Metrics/ClassLength
   class CLI
     DEFAULT_QUERY = 'tag:#project/active'
+    SOURCE_NATIVE = 'native'
+    SOURCE_OBSIDIAN = 'obsidian'
     VAULT_SOURCE_EXPLICIT = '--vault'
     VAULT_SOURCE_SAVED_DEFAULT = 'saved default'
     VAULT_SOURCE_SESSION = 'session'
     VAULT_SOURCE_OBSIDIAN_DEFAULT = 'obsidian default'
+    ROOT_SOURCE_EXPLICIT = '--root'
+    ROOT_SOURCE_CWD = 'current folder'
+    ROOT_SOURCE_SESSION = 'session'
     SearchAttempt = Data.define(:paths, :next_query)
 
     def initialize(argv, io: {}, app_name: 'architext', dependencies: {})
@@ -32,6 +37,8 @@ module Architext
       @app_name = app_name
       @options = {
         query: nil,
+        source: SOURCE_NATIVE,
+        root: Dir.pwd,
         vault: nil,
         set_default_vault: nil,
         clear_default_vault: false,
@@ -41,6 +48,7 @@ module Architext
         all: false
       }
       @vault_source = VAULT_SOURCE_OBSIDIAN_DEFAULT
+      @root_source = ROOT_SOURCE_CWD
     end
 
     def run
@@ -48,18 +56,20 @@ module Architext
       return 0 if handled_default_vault_options?
 
       apply_default_vault
+      normalize_source_options
       return run_diagnostics if @options[:diagnose]
 
       selected_paths = gather_selection
       return 1 unless selected_paths
       return no_selection if selected_paths.empty?
 
+      source = build_source
       if @options[:dry_run]
-        print_dry_run(selected_paths, Obsidian.new(vault: @options[:vault]))
+        print_dry_run(selected_paths, source)
         return 0
       end
 
-      files = read_selected_files(Obsidian.new(vault: @options[:vault]), selected_paths)
+      files = read_selected_files(source, selected_paths)
       bundle = Bundle.new(files).to_markdown
       write_output(bundle)
       0
@@ -71,7 +81,7 @@ module Architext
       ui.show_error "#{@app_name}: #{e.message}"
       @stderr.puts 'Install/enable Obsidian CLI, or set ARCHITEXT_OBSIDIAN to its path.'
       127
-    rescue Obsidian::CommandFailed => e
+    rescue Obsidian::CommandFailed, SourceError => e
       ui.show_error "#{@app_name}: #{e.message}"
       1
     rescue Interrupt
@@ -86,12 +96,25 @@ module Architext
       parser = OptionParser.new do |opts|
         opts.banner = "Usage: bin/#{@app_name} [options]"
 
-        opts.on('-q', '--query QUERY', "Obsidian search query. Default: #{DEFAULT_QUERY}") do |value|
+        opts.on('-q', '--query QUERY', "Markdown search query. Default: #{DEFAULT_QUERY}") do |value|
           @options[:query] = value
         end
 
+        opts.on('--source SOURCE', 'Search source: native or obsidian. Default: native') do |value|
+          source = value.to_s.strip.downcase
+          raise OptionParser::InvalidArgument, '--source must be native or obsidian' unless valid_source?(source)
+
+          @options[:source] = source
+        end
+
+        opts.on('--root PATH', 'Native markdown root. Default: current directory') do |value|
+          @options[:root] = value
+          @root_source = ROOT_SOURCE_EXPLICIT
+        end
+
         opts.on('-v', '--vault VAULT', 'Obsidian vault name or id') do |value|
           @options[:vault] = value
+          @options[:source] = SOURCE_OBSIDIAN
         end
 
         opts.on('--set-default-vault VAULT', 'Set persistent default vault for future runs') do |value|
@@ -102,7 +125,7 @@ module Architext
           @options[:clear_default_vault] = true
         end
 
-        opts.on('--diagnose', 'Print Obsidian CLI and vault diagnostics, then exit') do
+        opts.on('--diagnose', 'Print source diagnostics, then exit') do
           @options[:diagnose] = true
         end
 
@@ -133,16 +156,17 @@ module Architext
     end
     # rubocop:enable Metrics/BlockLength
 
+    def valid_source?(source)
+      [SOURCE_NATIVE, SOURCE_OBSIDIAN].include?(source)
+    end
+
     def gather_selection
       query = @options[:query] || prompt_for_query
       return nil if query.nil?
 
-      vault = @options[:vault]
-      vault_source = @vault_source
-
       loop do
-        client = Obsidian.new(vault:)
-        attempt = search_with_recovery(client, query)
+        source = build_source
+        attempt = search_with_recovery(source, query)
         if attempt.next_query
           query = attempt.next_query
           return nil if query.nil?
@@ -152,19 +176,15 @@ module Architext
 
         paths = attempt.paths
         if paths.empty?
-          query = handle_no_results(query, vault, vault_source)
+          query = handle_no_results(query, source.diagnostics)
           return nil if query.nil?
 
           next
         end
 
-        selection = select_paths(paths, query:, vault:, vault_source:)
-        if selection.new_vault
-          vault = selection.new_vault.strip
-          vault = nil if vault.empty?
-          @options[:vault] = vault
-          vault_source = vault.nil? ? VAULT_SOURCE_OBSIDIAN_DEFAULT : VAULT_SOURCE_SESSION
-          @vault_source = vault_source
+        selection = select_paths(paths, query:, diagnostics: source.diagnostics)
+        if selection.source_config
+          handle_prompt_source_config
           next
         end
 
@@ -216,6 +236,8 @@ module Architext
     end
 
     def apply_default_vault
+      return unless @options[:source] == SOURCE_OBSIDIAN
+
       if @options[:vault]
         @vault_source = VAULT_SOURCE_EXPLICIT
         return
@@ -226,6 +248,14 @@ module Architext
       @vault_source = default_vault ? VAULT_SOURCE_SAVED_DEFAULT : VAULT_SOURCE_OBSIDIAN_DEFAULT
     end
 
+    def normalize_source_options
+      @options[:root] = File.expand_path(@options[:root].to_s)
+      return unless @options[:source] == SOURCE_NATIVE
+
+      @options[:vault] = nil
+      @vault_source = VAULT_SOURCE_OBSIDIAN_DEFAULT
+    end
+
     def prompt_for_query
       return DEFAULT_QUERY unless interactive?
 
@@ -234,6 +264,9 @@ module Architext
         input = ui.prompt_query(
           default: DEFAULT_QUERY,
           context: {
+            source: @options[:source],
+            root: @options[:root],
+            root_source: @root_source,
             vault: @options[:vault],
             vault_source: @vault_source,
             default_vault: @settings.default_vault,
@@ -244,7 +277,7 @@ module Architext
         return nil if input.quit
 
         if input.open_vault_config
-          handle_prompt_vault_config
+          handle_prompt_source_config
           next
         end
 
@@ -253,49 +286,54 @@ module Architext
     end
 
     def build_connection_report
-      report = {
-        executable: ENV.fetch('ARCHITEXT_OBSIDIAN', 'obsidian'),
-        status: 'unknown',
+      diagnostics = build_source.diagnostics
+      warning = diagnostics.warning
+      warning ||= vault_mismatch_warning(diagnostics.resolved_vault_summary, @options[:vault]) if diagnostics.source == SOURCE_OBSIDIAN
+      diagnostics.to_h.merge(warning:)
+    rescue SourceError => e
+      SourceDiagnostics.new(
+        source: @options[:source],
+        root: @options[:root],
+        vault: @options[:vault],
+        vault_source: @vault_source,
+        status: 'error',
+        warning: e.message,
+        markdown_count: nil,
+        executable: nil,
         version: nil,
-        resolved_vault_summary: nil,
-        warning: nil
-      }
-      client = Obsidian.new(vault: @options[:vault], executable: report[:executable])
-      report[:version] = client.version
-      report[:resolved_vault_summary] = summarize_vault_info(client.vault_info)
-      report[:status] = 'ok'
-      report[:warning] = vault_mismatch_warning(report[:resolved_vault_summary], @options[:vault])
-      report
-    rescue Obsidian::CommandFailed => e
-      report[:status] = 'error'
-      report[:warning] = first_line(e.message)
-      report
-    rescue Obsidian::CommandNotFound => e
-      report[:status] = 'error'
-      report[:warning] = e.message
-      report
+        resolved_vault_summary: nil
+      ).to_h
     end
 
     def run_diagnostics
       report = build_connection_report
       @stdout.puts "ARCHiTEXT diagnostics (v#{Architext::VERSION})"
+      @stdout.puts "active source: #{report[:source]}"
+      report[:source] == SOURCE_OBSIDIAN ? print_obsidian_diagnostics(report) : print_native_diagnostics(report)
+      @stdout.puts "connection check: #{report[:status]}"
+      @stdout.puts "diagnostic warning: #{report[:warning]}" if report[:warning]
+      report[:status] == 'ok' ? 0 : 1
+    end
+
+    def print_native_diagnostics(report)
+      @stdout.puts "root path: #{report[:root]}"
+      @stdout.puts "markdown files: #{report[:markdown_count] || 'unknown'}"
+    end
+
+    def print_obsidian_diagnostics(report)
       @stdout.puts "active vault ref: #{@options[:vault] || '(none selected)'}"
       @stdout.puts "vault source: #{@vault_source}"
       @stdout.puts "saved default vault: #{@settings.default_vault || '(none)'}"
       @stdout.puts "default vault config path: #{@settings.config_path}"
       @stdout.puts "obsidian cli executable: #{report[:executable]}"
       @stdout.puts "obsidian cli version: #{report[:version] || 'unknown'}"
-      @stdout.puts "connection check: #{report[:status]}"
       @stdout.puts "resolved vault: #{report[:resolved_vault_summary] || '(unknown)'}"
-      @stdout.puts "diagnostic warning: #{report[:warning]}" if report[:warning]
-      report[:status] == 'ok' ? 0 : 1
     end
 
-    def handle_no_results(query, vault, vault_source)
+    def handle_no_results(query, diagnostics)
       ui.show_no_results(
         query,
-        vault:,
-        vault_source:,
+        diagnostics: diagnostics.to_h,
         default_vault_path: @settings.config_path,
         obsidian_executable: ENV.fetch('ARCHITEXT_OBSIDIAN', 'obsidian')
       )
@@ -311,48 +349,68 @@ module Architext
       raise error
     end
 
-    def select_paths(paths, query:, vault:, vault_source:)
-      return TUI::Selection.new(paths:, new_query: nil, new_vault: nil, reprompt_query: false) if @options[:all]
+    def select_paths(paths, query:, diagnostics:)
+      return TUI::Selection.new(paths:, new_query: nil, source_config: false, reprompt_query: false) if @options[:all]
 
-      unless interactive?
-        raise Obsidian::CommandFailed,
-              'interactive selection requires a TTY; rerun with --all or provide input from a terminal'
-      end
+      raise SourceError, 'interactive selection requires a TTY; rerun with --all or provide input from a terminal' unless interactive?
 
-      ui.select(paths, query:, vault:, vault_source:)
+      ui.select(paths, query:, diagnostics: diagnostics.to_h)
     end
 
-    def handle_prompt_vault_config
+    def handle_prompt_source_config
       loop do
-        action = ui.prompt_vault_config(
+        context = {
+          source: @options[:source],
+          root: @options[:root],
+          root_source: @root_source,
           active_vault: @options[:vault],
           active_vault_source: @vault_source,
           default_vault: @settings.default_vault,
           default_vault_path: @settings.config_path
-        )
+        }
+        action = ui.prompt_source_config(context)
         return if action.back
 
-        if action.clear_default
-          @settings.clear_default_vault
-          ui.show_info('Default vault cleared.')
-          next
-        end
+        apply_source_config_action(action)
+      end
+    end
 
-        if action.set_default_vault
-          @settings.default_vault = action.set_default_vault
-          ui.show_info("Default vault set to: #{action.set_default_vault}")
-          next
-        end
+    def build_source
+      return ObsidianSource.new(vault: @options[:vault], vault_source: @vault_source) if @options[:source] == SOURCE_OBSIDIAN
 
-        next unless action.session_vault
+      NativeMarkdownSource.new(root: @options[:root])
+    end
 
-        vault = action.session_vault.strip
-        vault = nil if vault.empty?
-        @options[:vault] = vault
-        @vault_source = vault.nil? ? VAULT_SOURCE_OBSIDIAN_DEFAULT : VAULT_SOURCE_SESSION
+    def apply_source_config_action(action)
+      if action.clear_default
+        @settings.clear_default_vault
+        ui.show_info('Default vault cleared.')
+      elsif action.set_default_vault
+        @settings.default_vault = action.set_default_vault
+        ui.show_info("Default vault set to: #{action.set_default_vault}")
+      elsif action.session_root
+        apply_native_root(action.session_root)
+      elsif action.session_vault
+        apply_obsidian_vault(action.session_vault)
       end
     end
 
+    def apply_native_root(root)
+      @options[:source] = SOURCE_NATIVE
+      @options[:root] = File.expand_path(root.strip)
+      @root_source = ROOT_SOURCE_SESSION
+      @options[:vault] = nil
+      @vault_source = VAULT_SOURCE_OBSIDIAN_DEFAULT
+    end
+
+    def apply_obsidian_vault(vault_value)
+      @options[:source] = SOURCE_OBSIDIAN
+      vault = vault_value.strip
+      vault = nil if vault.empty?
+      @options[:vault] = vault
+      @vault_source = vault.nil? ? VAULT_SOURCE_OBSIDIAN_DEFAULT : VAULT_SOURCE_SESSION
+    end
+
     def print_dry_run(selected_paths, client)
       files = read_selected_files(client, selected_paths)
       bytes = Bundle.new(files).to_markdown.bytesize
@@ -374,7 +432,7 @@ module Architext
       @clipboard.copy(bundle)
       ui.show_copied(bundle.bytesize)
     rescue Clipboard::Error => e
-      raise Obsidian::CommandFailed, "#{e.message}\nTip: rerun with --stdout to print the bundle."
+      raise SourceError, "#{e.message}\nTip: rerun with --stdout to print the bundle."
     end
 
     def query_uses_operators?(query)
@@ -397,25 +455,6 @@ module Architext
       nil
     end
 
-    def summarize_vault_info(text)
-      lines = text.to_s.lines.map(&:strip).reject(&:empty?)
-      kv = lines.each_with_object({}) do |line, memo|
-        next unless line.match?(/\A[a-zA-Z0-9_]+\s+/)
-
-        key, value = line.split(/\s+/, 2)
-        memo[key.downcase] = value
-      end
-
-      name = kv['name']
-      path = kv['path']
-      return "#{name} | #{path}" if name && path
-      return name if name
-      return path if path
-
-      compact = lines.join(' | ')
-      compact[0, 180]
-    end
-
     def vault_mismatch_warning(vault_summary, requested_vault)
       return nil if requested_vault.to_s.strip.empty?
       return nil if vault_summary.to_s.downcase.include?(requested_vault.to_s.downcase)
@@ -423,10 +462,6 @@ module Architext
       "Requested vault '#{requested_vault}' may not match resolved vault reported by Obsidian CLI."
     end
 
-    def first_line(text)
-      text.to_s.lines.first.to_s.strip
-    end
-
     def no_selection
       ui.show_no_selection
       1

data/lib/architext/sources.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+require 'find'
+require 'pathname'
+
+require_relative 'obsidian'
+
+module Architext
+  SourceDiagnostics = Data.define(
+    :source,
+    :root,
+    :vault,
+    :vault_source,
+    :status,
+    :warning,
+    :markdown_count,
+    :executable,
+    :version,
+    :resolved_vault_summary
+  )
+
+  class SourceError < StandardError; end
+  class SourceNotFound < SourceError; end
+
+  class NativeMarkdownSource
+    MARKDOWN_EXTENSIONS = %w[.md .markdown].freeze
+    EXCLUDED_DIRECTORIES = %w[.git .bundle node_modules vendor].freeze
+
+    SearchToken = Data.define(:kind, :value)
+    SearchResult = Data.define(:path, :score)
+
+    attr_reader :root
+
+    def initialize(root: Dir.pwd)
+      @root = File.realpath(File.expand_path(root.to_s))
+    rescue Errno::ENOENT, Errno::ENOTDIR
+      raise SourceNotFound, "Markdown root not found: #{root}"
+    end
+
+    def search(query)
+      tokens = parse_query(query)
+      results = markdown_files.filter_map do |path|
+        relative = relative_path(path)
+        content = read_absolute(path)
+        next unless tokens.empty? || tokens.all? { |token| token_matches?(token, relative, content) }
+
+        SearchResult.new(path: relative, score: relevance_score(tokens, relative, content))
+      end
+
+      results.uniq(&:path)
+             .sort_by { |result| [-result.score, result.path.downcase] }
+             .map(&:path)
+    end
+
+    def read(path)
+      absolute = resolve_relative(path)
+      raise SourceNotFound, "Markdown file not found: #{path}" unless File.file?(absolute)
+      raise SourceError, "Not a markdown file: #{path}" unless markdown_file?(absolute)
+
+      read_absolute(absolute)
+    end
+
+    def diagnostics
+      SourceDiagnostics.new(
+        source: 'native',
+        root: @root,
+        vault: nil,
+        vault_source: nil,
+        status: 'ok',
+        warning: nil,
+        markdown_count: markdown_files.length,
+        executable: nil,
+        version: nil,
+        resolved_vault_summary: nil
+      )
+    rescue SourceError => e
+      SourceDiagnostics.new(
+        source: 'native',
+        root: @root,
+        vault: nil,
+        vault_source: nil,
+        status: 'error',
+        warning: e.message,
+        markdown_count: nil,
+        executable: nil,
+        version: nil,
+        resolved_vault_summary: nil
+      )
+    end
+
+    private
+
+    def markdown_files
+      files = []
+      Find.find(@root) do |path|
+        if File.directory?(path)
+          Find.prune if excluded_directory?(path)
+          next
+        end
+
+        files << path if markdown_file?(path)
+      end
+      files.sort_by { |path| relative_path(path).downcase }
+    end
+
+    def excluded_directory?(path)
+      return false if path == @root
+
+      basename = File.basename(path)
+      basename.start_with?('.') || EXCLUDED_DIRECTORIES.include?(basename)
+    end
+
+    def markdown_file?(path)
+      MARKDOWN_EXTENSIONS.include?(File.extname(path).downcase)
+    end
+
+    def parse_query(query)
+      query.to_s.scan(/"([^"]+)"|(\S+)/).filter_map do |quoted, bare|
+        raw = (quoted || bare).to_s.strip
+        next if raw.empty?
+
+        case raw
+        when /\Atag:(.+)\z/i
+          SearchToken.new(kind: :tag, value: Regexp.last_match(1).sub(/\A#/, '').downcase)
+        when /\A(?:path|file):(.+)\z/i
+          SearchToken.new(kind: :path, value: Regexp.last_match(1).downcase)
+        else
+          SearchToken.new(kind: :text, value: raw.downcase)
+        end
+      end
+    end
+
+    def token_matches?(token, relative, content)
+      path = relative.downcase
+      text = content.downcase
+
+      case token.kind
+      when :path
+        path.include?(token.value)
+      when :tag
+        tag_matches?(token.value, content)
+      else
+        path.include?(token.value) || text.include?(token.value)
+      end
+    end
+
+    def tag_matches?(tag, content)
+      return false if tag.empty?
+
+      escaped = Regexp.escape(tag)
+      pattern = if tag.include?('/')
+                  %r{(?<![\w/-])##{escaped}(?![\w/-])}i
+                else
+                  %r{(?<![\w/-])##{escaped}(?:/[\w-]+)*(?![\w/-])}i
+                end
+      content.match?(pattern)
+    end
+
+    def relevance_score(tokens, relative, content)
+      return 0 if tokens.empty?
+
+      path = relative.downcase
+      text = content.downcase
+      tokens.sum do |token|
+        case token.kind
+        when :path
+          path.include?(token.value) ? 30 : 0
+        when :tag
+          tag_matches?(token.value, content) ? 40 : 0
+        else
+          (path.include?(token.value) ? 20 : 0) + text.scan(Regexp.escape(token.value)).length
+        end
+      end
+    end
+
+    def resolve_relative(path)
+      requested = Pathname.new(File.expand_path(path.to_s, @root)).cleanpath
+      root_path = Pathname.new(@root)
+      relative = requested.relative_path_from(root_path).to_s
+      raise SourceError, "Path escapes markdown root: #{path}" if relative.start_with?('..')
+
+      requested.to_s
+    rescue ArgumentError
+      raise SourceError, "Path escapes markdown root: #{path}"
+    end
+
+    def relative_path(path)
+      Pathname.new(path).relative_path_from(Pathname.new(@root)).to_s
+    end
+
+    def read_absolute(path)
+      text = File.binread(path).to_s
+      text.force_encoding(Encoding::UTF_8)
+      text.valid_encoding? ? text : text.scrub
+    rescue Errno::EACCES
+      raise SourceError, "Cannot read markdown file: #{relative_path(path)}"
+    end
+  end
+
+  class ObsidianSource
+    attr_reader :vault, :vault_source
+
+    def initialize(vault: nil, vault_source: nil, executable: ENV.fetch('ARCHITEXT_OBSIDIAN', 'obsidian'))
+      @vault = vault
+      @vault_source = vault_source
+      @executable = executable
+      @client = Obsidian.new(vault:, executable:)
+    end
+
+    def search(query)
+      @client.search(query)
+    end
+
+    def read(path)
+      @client.read(path)
+    end
+
+    def diagnostics
+      version = @client.version
+      vault_info = @client.vault_info
+      SourceDiagnostics.new(
+        source: 'obsidian',
+        root: nil,
+        vault: @vault,
+        vault_source: @vault_source,
+        status: 'ok',
+        warning: nil,
+        markdown_count: nil,
+        executable: @executable,
+        version:,
+        resolved_vault_summary: summarize_vault_info(vault_info)
+      )
+    rescue Obsidian::CommandFailed => e
+      SourceDiagnostics.new(
+        source: 'obsidian',
+        root: nil,
+        vault: @vault,
+        vault_source: @vault_source,
+        status: 'error',
+        warning: first_line(e.message),
+        markdown_count: nil,
+        executable: @executable,
+        version: nil,
+        resolved_vault_summary: nil
+      )
+    end
+
+    private
+
+    def summarize_vault_info(text)
+      lines = text.to_s.lines.map(&:strip).reject(&:empty?)
+      kv = lines.each_with_object({}) do |line, memo|
+        next unless line.match?(/\A[a-zA-Z0-9_]+\s+/)
+
+        key, value = line.split(/\s+/, 2)
+        memo[key.downcase] = value
+      end
+
+      name = kv['name']
+      path = kv['path']
+      return "#{name} | #{path}" if name && path
+      return name if name
+      return path if path
+
+      lines.join(' | ')[0, 180]
+    end
+
+    def first_line(text)
+      text.to_s.lines.first.to_s.strip
+    end
+  end
+end

data/lib/architext/tui.rb

@@ -8,7 +8,7 @@ require_relative 'version'
 module Architext
   # rubocop:disable Metrics/ClassLength
   class TUI
-    HELP = 'Up/k Down/j move  space select  a all  / filter  n new search  v vault  enter confirm  q back'
+    HELP = 'Up/k Down/j move  space select  a all  / filter  n new search  v source  enter confirm  q back'
     KEY_BINDINGS = {
       ' ' => :space,
       'k' => :up,
@@ -27,9 +27,9 @@ module Architext
       '/_/  |_/_/   \\___/_/ /_/_/\\__/\\___/_/|_|\\__/  '
     ].freeze
 
-    Selection = Data.define(:paths, :new_query, :new_vault, :reprompt_query)
+    Selection = Data.define(:paths, :new_query, :source_config, :reprompt_query)
     QueryPrompt = Data.define(:query, :open_vault_config, :quit)
-    VaultConfigAction = Data.define(:session_vault, :set_default_vault, :clear_default, :back)
+    SourceConfigAction = Data.define(:session_root, :session_vault, :set_default_vault, :clear_default, :back)
 
     def initialize(stdin:, stdout:, stderr:, app_name:)
       @stdin = stdin
@@ -42,14 +42,8 @@ module Architext
 
     def prompt_query(default:, context:)
       draw_intro
-      draw_startup_vault_status(
-        context[:vault],
-        context[:vault_source],
-        context[:default_vault],
-        context[:default_vault_path],
-        context[:connection_report]
-      )
-      @stdout.print render("[bold][cyan]Search query[/] [dim](default: #{default})[/] [dim]| type 'v' for vault config, 'q' to quit:[/] ")
+      draw_startup_source_status(context)
+      @stdout.print render("[bold][cyan]Search query[/] [dim](default: #{default})[/] [dim]| type 'v' for source config, 'q' to quit:[/] ")
       input = @stdin.gets&.strip
       return QueryPrompt.new(query: nil, open_vault_config: false, quit: true) if input.nil?
 
@@ -61,49 +55,54 @@ module Architext
     end
 
     # rubocop:disable Metrics/AbcSize
-    def prompt_vault_config(active_vault:, active_vault_source:, default_vault:, default_vault_path:)
+    def prompt_source_config(context)
       draw_intro
-      @stdout.puts render('[bold][cyan]Vault Configuration[/]')
-      @stdout.puts render("[dim]active:[/] #{format_vault_label(active_vault, active_vault_source)}")
-      @stdout.puts render("[dim]saved default:[/] #{format_saved_default(default_vault)}")
-      @stdout.puts render("[dim]default config path:[/] #{default_vault_path}")
-      @stdout.puts render('[dim]vault path resolution is handled by Obsidian CLI via vault=<name_or_id>.[/]')
+      @stdout.puts render('[bold][cyan]Source Configuration[/]')
+      @stdout.puts render("[dim]active source:[/] [cyan]#{context[:source]}[/]")
+      @stdout.puts render("[dim]native root:[/] #{format_root_label(context[:root], context[:root_source])}")
+      @stdout.puts render("[dim]obsidian vault:[/] #{format_vault_label(context[:active_vault], context[:active_vault_source])}")
+      @stdout.puts render("[dim]saved Obsidian default:[/] #{format_saved_default(context[:default_vault])}")
+      @stdout.puts render("[dim]Obsidian default config path:[/] #{context[:default_vault_path]}")
       @stdout.puts
       @stdout.puts render('[dim]Commands:[/]')
-      @stdout.puts render('  [cyan]use <vault>[/] [dim]set active vault for this run[/]')
-      @stdout.puts render('  [cyan]save <vault>[/] [dim]save persistent default vault[/]')
-      @stdout.puts render('  [cyan]clear[/] [dim]clear persistent default vault[/]')
-      @stdout.puts render('  [cyan]none[/] [dim]clear active vault (use Obsidian CLI default)[/]')
+      @stdout.puts render('  [cyan]root <path>[/] [dim]use native markdown search in a folder[/]')
+      @stdout.puts render('  [cyan]vault <vault>[/] [dim]use Obsidian CLI with a vault name or id[/]')
+      @stdout.puts render('  [cyan]save <vault>[/] [dim]save persistent Obsidian default vault[/]')
+      @stdout.puts render('  [cyan]clear[/] [dim]clear persistent Obsidian default vault[/]')
+      @stdout.puts render('  [cyan]none[/] [dim]use Obsidian CLI default vault[/]')
       @stdout.puts render('  [cyan]back[/] [dim]return to search prompt[/]')
       @stdout.puts
-      @stdout.print render('[bold][cyan]vault-config[/]> ')
+      @stdout.print render('[bold][cyan]source-config[/]> ')
       input = @stdin.gets&.strip
-      return VaultConfigAction.new(session_vault: nil, set_default_vault: nil, clear_default: false, back: true) if input.nil?
+      return source_config_action(back: true) if input.nil?
 
       command = input.strip
-      return VaultConfigAction.new(session_vault: nil, set_default_vault: nil, clear_default: false, back: true) if command.empty?
-      return VaultConfigAction.new(session_vault: nil, set_default_vault: nil, clear_default: false, back: true) if command.casecmp('back').zero?
-      return VaultConfigAction.new(session_vault: '', set_default_vault: nil, clear_default: false, back: false) if command.casecmp('none').zero?
-      return VaultConfigAction.new(session_vault: nil, set_default_vault: nil, clear_default: true, back: false) if command.casecmp('clear').zero?
+      return source_config_action(back: true) if command.empty?
+      return source_config_action(back: true) if command.casecmp('back').zero?
+      return source_config_action(session_vault: '') if command.casecmp('none').zero?
+      return source_config_action(clear_default: true) if command.casecmp('clear').zero?
 
       if (match = command.match(/\Asave\s+(.+)\z/i))
-        return VaultConfigAction.new(session_vault: nil, set_default_vault: match[1].strip, clear_default: false, back: false)
+        return source_config_action(set_default_vault: match[1].strip)
       end
 
-      if (match = command.match(/\Ause\s+(.+)\z/i))
-        return VaultConfigAction.new(session_vault: match[1].strip, set_default_vault: nil, clear_default: false, back: false)
+      if (match = command.match(/\A(?:root|native)\s+(.+)\z/i))
+        return source_config_action(session_root: match[1].strip)
       end
 
-      VaultConfigAction.new(session_vault: command, set_default_vault: nil, clear_default: false, back: false)
+      if (match = command.match(/\A(?:vault|obsidian|use)\s+(.+)\z/i))
+        return source_config_action(session_vault: match[1].strip)
+      end
+
+      source_config_action(session_root: command)
     end
     # rubocop:enable Metrics/AbcSize
 
-    # rubocop:disable Metrics/BlockLength, Metrics/MethodLength
-    def select(paths, query:, vault:, vault_source:)
+    # rubocop:disable Metrics/BlockLength
+    def select(paths, query:, diagnostics:)
       state = {
         query: query,
-        vault: vault,
-        vault_source: vault_source,
+        diagnostics: diagnostics,
         filter: '',
         cursor: 0,
         offset: 0,
@@ -130,24 +129,24 @@ module Architext
           when :new_query
             return Selection.new(
               paths: [],
-              new_query: prompt_inline('New Obsidian search', state[:query]),
-              new_vault: nil,
+              new_query: prompt_inline('New markdown search', state[:query]),
+              source_config: false,
               reprompt_query: false
             )
           when :new_vault
             return Selection.new(
               paths: [],
               new_query: nil,
-              new_vault: prompt_inline('Vault name or id (blank clears)', state[:vault].to_s),
+              source_config: true,
               reprompt_query: false
             )
           when :enter
             selected = selected_paths(paths, state)
-            return Selection.new(paths: selected, new_query: nil, new_vault: nil, reprompt_query: false)
+            return Selection.new(paths: selected, new_query: nil, source_config: false, reprompt_query: false)
           when :quit
-            return Selection.new(paths: [], new_query: nil, new_vault: nil, reprompt_query: true)
+            return Selection.new(paths: [], new_query: nil, source_config: false, reprompt_query: true)
           when :ctrl_c
-            return Selection.new(paths: [], new_query: nil, new_vault: nil, reprompt_query: false)
+            return Selection.new(paths: [], new_query: nil, source_config: false, reprompt_query: false)
           end
 
           clamp_cursor!(state, visible.length)
@@ -155,14 +154,15 @@ module Architext
         end
       end
     end
-    # rubocop:enable Metrics/BlockLength, Metrics/MethodLength
+    # rubocop:enable Metrics/BlockLength
 
-    def show_no_results(query, vault:, vault_source:, default_vault_path:, obsidian_executable:)
-      vault_label = format_vault_label(vault, vault_source)
-      @stderr.puts render("[red]No Obsidian notes matched[/] [amber]#{query.inspect}[/]  #{vault_label}")
-      @stderr.puts render("[dim]default vault config:[/] #{default_vault_path}")
-      @stderr.puts render("[dim]obsidian cli:[/] #{obsidian_executable}")
-      @stderr.puts render('[amber]Tip:[/] at search prompt type [bold]v[/] for vault config, or pass [bold]--vault[/].')
+    def show_no_results(query, diagnostics:, default_vault_path:, obsidian_executable:)
+      @stderr.puts render("[red]No markdown notes matched[/] [amber]#{query.inspect}[/]  #{format_source_label(diagnostics)}")
+      if diagnostics[:source] == 'obsidian'
+        @stderr.puts render("[dim]default vault config:[/] #{default_vault_path}")
+        @stderr.puts render("[dim]obsidian cli:[/] #{obsidian_executable}")
+      end
+      @stderr.puts render('[amber]Tip:[/] at search prompt type [bold]v[/] for source config, or pass [bold]--root[/].')
     end
 
     def show_no_selection
@@ -192,6 +192,16 @@ module Architext
 
     private
 
+    def source_config_action(
+      session_root: nil,
+      session_vault: nil,
+      set_default_vault: nil,
+      clear_default: false,
+      back: false
+    )
+      SourceConfigAction.new(session_root:, session_vault:, set_default_vault:, clear_default:, back:)
+    end
+
     def draw_intro
       return unless @stdout.tty?
       return if @intro_rendered
@@ -212,7 +222,7 @@ module Architext
           styled = logo_style ? Terminal.paint(line, logo_style, enabled: @color) : line
           @stdout.puts center(styled, width)
         end
-        @stdout.puts center(render('[dim]Architect Obsidian context and stitch for agent work[/]'), width)
+        @stdout.puts center(render('[dim]Architect markdown context and stitch for agent work[/]'), width)
         version = "v#{Architext::VERSION}"
         styled_version = version_style ? Terminal.paint(version, version_style, enabled: @color) : version
         @stdout.puts center(styled_version, width)
@@ -280,7 +290,7 @@ module Architext
     def header_lines(width, state, total, visible_count)
       filter_label = state[:filter].empty? ? 'none' : state[:filter]
       [
-        Terminal.truncate(render("[bold][cyan]ARCHiTEXT[/] [dim]#{state[:vault] || 'obsidian default'}[/]"), width),
+        Terminal.truncate(render("[bold][cyan]ARCHiTEXT[/] [dim]#{format_source_label(state[:diagnostics])}[/]"), width),
         Terminal.truncate(render("[dim]query:[/] [amber]#{state[:query]}[/]  [dim]filter:[/] [cyan]#{filter_label}[/]"), width),
         Terminal.truncate(render("[dim]results:[/] #{visible_count}/#{total}  [dim]selected:[/] #{state[:selected].length}"), width),
         Terminal.paint('-' * width, :faint, enabled: @color)
@@ -482,20 +492,36 @@ module Architext
       Terminal.render(markup, enabled: @color)
     end
 
-    def draw_startup_vault_status(vault, vault_source, default_vault, default_vault_path, connection_report)
-      @stdout.puts render("[dim]active vault:[/] #{format_vault_label(vault, vault_source)}")
-      @stdout.puts render("[dim]saved default:[/] #{format_saved_default(default_vault)}")
-      @stdout.puts render("[dim]default config path:[/] #{default_vault_path}")
-      @stdout.puts render("[dim]obsidian cli:[/] #{connection_report[:executable]}")
-      @stdout.puts render("[dim]obsidian version:[/] #{connection_report[:version] || 'unknown'}")
+    def draw_startup_source_status(context)
+      connection_report = context[:connection_report]
+      @stdout.puts render("[dim]active source:[/] #{format_source_label(connection_report)}")
+      @stdout.puts render("[dim]native root:[/] #{format_root_label(context[:root], context[:root_source])}")
+      if connection_report[:source] == 'obsidian'
+        @stdout.puts render("[dim]obsidian vault:[/] #{format_vault_label(context[:vault], context[:vault_source])}")
+        @stdout.puts render("[dim]saved Obsidian default:[/] #{format_saved_default(context[:default_vault])}")
+        @stdout.puts render("[dim]default vault config path:[/] #{context[:default_vault_path]}")
+        @stdout.puts render("[dim]obsidian cli:[/] #{connection_report[:executable]}")
+        @stdout.puts render("[dim]obsidian version:[/] #{connection_report[:version] || 'unknown'}")
+      else
+        @stdout.puts render("[dim]markdown files:[/] #{connection_report[:markdown_count] || 'unknown'}")
+      end
       status_style = connection_report[:status] == 'ok' ? '[green]ok[/]' : '[red]error[/]'
       @stdout.puts render("[dim]connection check:[/] #{status_style}")
       @stdout.puts render("[dim]resolved vault:[/] #{connection_report[:resolved_vault_summary]}") if connection_report[:resolved_vault_summary]
       @stdout.puts render("[amber]diagnostic:[/] #{connection_report[:warning]}") if connection_report[:warning]
-      @stdout.puts render('[dim]vault target semantics: CWD vault if inside one, otherwise active Obsidian vault unless overridden.[/]')
       @stdout.puts
     end
 
+    def format_source_label(diagnostics)
+      return format_root_label(diagnostics[:root], 'root') if diagnostics[:source] == 'native'
+
+      format_vault_label(diagnostics[:vault], diagnostics[:vault_source] || 'obsidian')
+    end
+
+    def format_root_label(root, source)
+      "[cyan]#{root}[/] [dim](#{source})[/]"
+    end
+
     def format_vault_label(vault, source)
       return "[amber]none selected[/] [dim](#{source})[/]" if vault.to_s.strip.empty?
 

data/lib/architext/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Architext
-  VERSION = '0.2.0'
+  VERSION = '1.0.0'
 end

data/lib/architext.rb

@@ -9,5 +9,6 @@ require_relative 'architext/terminal'
 require_relative 'architext/search_results'
 require_relative 'architext/selection_parser'
 require_relative 'architext/settings'
+require_relative 'architext/sources'
 require_relative 'architext/tui'
 require_relative 'architext/version'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: architext
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Can
@@ -79,8 +79,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
-description: A terminal interface to interactively select and bundle Obsidian notes
-  for AI agent context.
+description: A terminal interface to interactively search, select, and bundle markdown
+  notes for AI agent context.
 executables:
 - architext
 extensions: []
@@ -100,6 +100,7 @@ files:
 - lib/architext/search_results.rb
 - lib/architext/selection_parser.rb
 - lib/architext/settings.rb
+- lib/architext/sources.rb
 - lib/architext/terminal.rb
 - lib/architext/tui.rb
 - lib/architext/version.rb
@@ -129,5 +130,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: A visual Obsidian context stitching TUI for agent workflows.
+summary: A visual markdown context stitching TUI for agent workflows.
 test_files: []