Merge pull request #32 from dexoron/dev

feat: add package.dcr-version pin with load-time compatibility warnings
2026-10-21 22:39:37 +00:00 · 2026-08-08 15:00:02 +08:00 · 2026-08-08 14:33:46 +08:00 · 2026-08-05 21:22:20 +08:00 · 2026-08-05 19:21:00 +08:00 · 2026-08-05 02:21:29 +08:00
104 changed files with 6571 additions and 937 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -5,10 +5,18 @@ on:
    branches:
      - master
      - main
+      - dev
  pull_request:

+env:
+  CARGO_TERM_COLOR: always
+  RUSTFLAGS: -Dwarnings
+  CARGO_INCREMENTAL: "0"
+  SCCACHE_GHA_ENABLED: "true"
+
 jobs:
  checks:
+    name: fmt / clippy / check
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
@@ -18,11 +26,129 @@ jobs:
        with:
          components: rustfmt, clippy

+      - name: sccache
+        uses: mozilla-actions/sccache-action@v0.0.9
+
+      - uses: Swatinem/rust-cache@v2
+        with:
+          shared-key: dcr-ci
+          cache-all-crates: true
+
      - name: Format
        run: cargo fmt --all --check

-      - name: Lint
+      - name: Clippy (default features)
+        run: cargo clippy --all-targets -- -D warnings
+
+      - name: Clippy (all features)
        run: cargo clippy --all-targets --all-features -- -D warnings

-      - name: Check
+      - name: Check (all features)
        run: cargo check --all-targets --all-features
+
+  test:
+    name: tests (${{ matrix.os }})
+    needs: checks
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: sccache
+        uses: mozilla-actions/sccache-action@v0.0.9
+
+      - uses: Swatinem/rust-cache@v2
+        with:
+          shared-key: dcr-ci
+          cache-all-crates: true
+          cache-on-failure: true
+
+      - name: Cache apt packages
+        if: runner.os == 'Linux'
+        uses: actions/cache@v4
+        with:
+          path: /var/cache/apt/archives
+          key: apt-${{ runner.os }}-${{ hashFiles('.github/workflows/ci.yml') }}
+          restore-keys: apt-${{ runner.os }}-
+
+      - name: Install Linux tools
+        if: runner.os == 'Linux'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y \
+            build-essential \
+            clang \
+            nasm \
+            clang-format \
+            clang-tidy \
+            git \
+            llvm
+
+      - name: Install macOS tools
+        if: runner.os == 'macOS'
+        run: |
+          brew install nasm llvm || true
+          echo "$(brew --prefix llvm)/bin" >> "$GITHUB_PATH"
+
+      - name: Install Windows tools
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: |
+          choco install nasm llvm -y
+          echo "C:\Program Files\NASM" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+          if (Test-Path "C:\Program Files\LLVM\bin") {
+            echo "C:\Program Files\LLVM\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+          }
+
+      - name: Unit tests (binary crate)
+        run: cargo test --bins -- --nocapture
+
+      - name: Integration tests (default features)
+        run: cargo test --tests -- --nocapture
+
+      - name: Integration tests (archive feature)
+        if: runner.os != 'Windows'
+        run: cargo test --tests --features archive -- --nocapture
+
+      - name: sccache stats
+        if: always()
+        run: sccache --show-stats || true
+
+  test-archive-linux:
+    name: archive feature smoke
+    needs: checks
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: sccache
+        uses: mozilla-actions/sccache-action@v0.0.9
+
+      - uses: Swatinem/rust-cache@v2
+        with:
+          shared-key: dcr-ci
+          cache-all-crates: true
+
+      - name: Install tools
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y build-essential clang nasm llvm
+
+      - name: Build with archive
+        run: cargo build --features archive
+
+      - name: Flat-bin + unit suite with archive
+        run: cargo test --features archive --test cli_build --test cli_workspace --test cli_errors -- --nocapture
+
+      - name: sccache stats
+        if: always()
+        run: sccache --show-stats || true
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -223,9 +223,9 @@ jobs:
      - name: Build
        run: |
          if [ "${{ matrix.target }}" != "x86_64-unknown-linux-gnu" ]; then
-            cargo zigbuild --release --target ${{ matrix.target }}
+            cargo zigbuild --release --features archive --target ${{ matrix.target }}
          else
-            cargo build --release --target ${{ matrix.target }}
+            cargo build --release --features archive --target ${{ matrix.target }}
          fi

      - name: Prepare Artifact
@@ -298,9 +298,9 @@ jobs:
        run: |
          cargo install cargo-deb
          if [ "${{ matrix.target }}" != "x86_64-unknown-linux-gnu" ]; then
-            cargo zigbuild --release --target ${{ matrix.target }}
+            cargo zigbuild --release --features archive --target ${{ matrix.target }}
          else
-            cargo build --release --target ${{ matrix.target }}
+            cargo build --release --features archive --target ${{ matrix.target }}
          fi
          cargo deb --no-build --target ${{ matrix.target }}
          mkdir -p dist-packages && cp target/${{ matrix.target }}/debian/*.deb dist-packages/
@@ -311,9 +311,9 @@ jobs:
        run: |
          cargo install cargo-generate-rpm
          if [ "${{ matrix.target }}" != "x86_64-unknown-linux-gnu" ]; then
-            cargo zigbuild --release --target ${{ matrix.target }}
+            cargo zigbuild --release --features archive --target ${{ matrix.target }}
          else
-            cargo build --release --target ${{ matrix.target }}
+            cargo build --release --features archive --target ${{ matrix.target }}
          fi
          cargo generate-rpm --target ${{ matrix.target }}
          mkdir -p dist-packages && cp target/${{ matrix.target }}/generate-rpm/*.rpm dist-packages/
@@ -322,7 +322,7 @@ jobs:
      - name: Build Snap Package
        if: matrix.package_type == 'snap'
        run: |
-          cargo build --release
+          cargo build --release --features archive
          mkdir -p packaging/snap/dist/bin
          cp target/release/dcr packaging/snap/dist/bin/
          cp -r man packaging/snap/dist/man
@@ -364,7 +364,7 @@ jobs:
            cd "\$srcdir/\$pkgname-${PKGVER_ORIG}"
            unset CFLAGS CXXFLAGS LDFLAGS
            export RUSTFLAGS="-C linker=cc"
-            cargo build --release --locked
+            cargo build --release --locked --features archive
          }
          package() {
            cd "\$srcdir/dcr-${PKGVER_ORIG}"
@@ -454,7 +454,7 @@ jobs:
          targets: ${{ matrix.target }}

      - name: Build
-        run: cargo build --release --target ${{ matrix.target }}
+        run: cargo build --release --features archive --target ${{ matrix.target }}

      - name: Prepare Artifact
        run: |
@@ -499,7 +499,7 @@ jobs:
          run: |
            export PATH="/usr/local/bin:/usr/local/sbin:$PATH"
            pkg install -y rust perl5 gmake
-            cargo build --release
+            cargo build --release --features archive

      - name: Prepare FreeBSD Artifact
        if: matrix.system == 'freebsd'
@@ -517,7 +517,7 @@ jobs:
          run: |
            export PATH="/usr/local/bin:$PATH"
            pkg_add rust perl gmake
-            cargo build --release
+            cargo build --release --features archive

      - name: Prepare OpenBSD Artifact
        if: matrix.system == 'openbsd'
@@ -537,7 +537,7 @@ jobs:
            mkdir -p /tmp/bin
            ln -sf /usr/pkg/bin/gmake /tmp/bin/make
            export PATH="/tmp/bin:/usr/pkg/bin:/usr/pkg/sbin:$PATH"
-            cargo build --release
+            cargo build --release --features archive

      - name: Prepare NetBSD Artifact
        if: matrix.system == 'netbsd'
@@ -585,7 +585,7 @@ jobs:
          targets: ${{ matrix.target }}

      - name: Build
-        run: cargo build --release --target ${{ matrix.target }}
+        run: cargo build --release --features archive --target ${{ matrix.target }}

      - name: Prepare Artifact
        shell: pwsh
@@ -654,7 +654,7 @@ jobs:
            cd "\$srcdir/\$pkgname-${PKGVER_ORIG}"
            unset CFLAGS CXXFLAGS LDFLAGS
            export RUSTFLAGS="-C linker=cc"
-            cargo build --release --locked
+            cargo build --release --locked --features archive
          }

          package() {
@@ -919,7 +919,7 @@ jobs:
            cd "\$srcdir/dcr-${PKGVER_ORIG}"
            unset CFLAGS CXXFLAGS LDFLAGS
            export RUSTFLAGS="-C linker=cc"
-            cargo build --release --locked
+            cargo build --release --locked --features archive
          }

          package() {
--- a/.github/workflows/trigger-site-build.yml
+++ b/.github/workflows/trigger-site-build.yml
@@ -0,0 +1,14 @@
+name: Trigger site rebuild
+
+on:
+  push:
+    branches: [master]
+    paths:
+      - 'docs/**'
+
+jobs:
+  trigger:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Trigger Cloudflare Pages build
+        run: curl -sS -X POST "${{ secrets.CF_PAGES_DEPLOY_HOOK }}"
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -1,56 +0,0 @@
-# AGENTS.md
-
-## Quick start
-
-```bash
-cargo build --release && ./target/release/dcr setup
-```
-
-## Pre-PR (CI) gate
-
-```bash
-cargo fmt --all --check
-cargo clippy --all-targets --all-features -- -D warnings
-cargo check --all-targets --all-features
-cargo test
-```
-
-CI (`.github/workflows/ci.yml`) runs fmt, clippy, check — **not** tests.
-
-## Tests
-
- Integration tests in `tests/` build the dcr binary and run it in temp dirs under `sandbox/cli-tests/` (gitignored).
- Some tests **skip** if no C compiler (`gcc`/`clang`/`cc`) is found at runtime.
- Compiler can be overridden via `DCR_COMPILER` or `DCR_CC` env vars.
- Tests use `$CARGO_BIN_EXE_dcr` when available, else `target/debug/dcr`.
-
-## Architecture
-
- **Single Rust package** (edition 2024), not a workspace. Only one binary: `dcr`.
- **Entrypoint**: `src/main.rs` — matches `args[1]` against command names.
- **Compiler backends** in `src/core/builder/`: `unix_cc` (gcc/clang), `msvc` (cl/clang-cl), `gas`, `nasm`. Dispatched by matching compiler name string.
- **Config**: `dcr.toml` (per-project), `~/.dcr/config.toml` (registry), `~/.dcr/index.json` (index). Defaults: `language=c`, `standard=c11`, `compiler=clang`, `kind=bin`.
- **`build.rs`** embeds `TARGET` as `DCR_TARGET` env var (shown in `--version`).
- **CLI output** must be in English. Use `utils::log` for messaging.
-
-## Key commands
-
-| Command | Notes |
-|---|---|
-| `dcr new <name>` | Creates project dir |
-| `dcr init` | Init from CWD (must be empty) |
-| `dcr build [--debug\|--release] [--target <triple>]` | Default profile: `--debug` |
-| `dcr run [--debug\|--release]` | Only for `kind = "bin"` |
-| `dcr clean [--debug\|--release] [--all]` | `--all` for workspace roots |
-| `dcr tree` | Dependency tree viewer |
-| `dcr test [--init]` | Runs/test project tests |
-| `dcr gen <vscode\|clion\|compile-commands>` | IDE integration |
-| `dcr --update` | Self-update from GitHub Releases |
-
-## Cross-compilation
-
-`--target` accepts short names (`linux`, `macos`, `windows`) or full triples. In CI, Linux cross-builds use `cargo-zigbuild`. When `build.target` is set in `dcr.toml`, DCR auto-injects `--target=<value>` into cflags (clang). Bare-metal targets (containing `none`/`-elf`/`eabi`/`baremetal`) skip DCR's default compiler flags.
-
-## Dependencies (Cargo)
-
-reqwest (blocking+json+rustls-tls), serde, toml, git2, openssl (vendored), self-replace, sha2, ctrlc.
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,209 @@
 # Changelog

+## [v0.8.5] - 2026-08-08 "Фиксация версии dcr-version и предупреждения совместимости / Config Version Pinning & Compatibility Warnings"
+
+### RU
+
+**Добавлено:**
+
+- **`package.dcr-version`** — опциональный pin версии CLI в `dcr.toml`.
+  `dcr new` / `dcr init` пишут текущую версию. При загрузке конфига:
+  - нет / пустой pin → warn «добавь dcr-version»;
+  - dcr старше pin → warn «обнови dcr»;
+  - dcr новее pin → warn «проверь changelog, подними pin»;
+  - равенство — тишина.
+    Команды не падают, только предупреждение (раз на path за процесс).
+
+### EN
+
+**Added:**
+
+- **`package.dcr-version`** — optional CLI version pin in `dcr.toml`.
+  `dcr new` / `dcr init` write the current version. On config load:
+  - missing / empty pin → warn "add dcr-version";
+  - dcr older than pin → warn "update dcr";
+  - dcr newer than pin → warn "check changelog, update pin";
+  - equal → silent.
+    Commands do not fail, warning only (once per path per process).
+
+## [0.8.4] - 2026-08-04 "Инфраструктура .dcr/ и интеграция с IDE / Internal .dcr/ Layout & IDE Integration"
+
+### RU
+
+**Добавлено:**
+
+- **Директория `.dcr/`** — единый machine-readable источник фактов о сборке для IDE/расширений:
+  - `.dcr/compile_commands.json`
+  - `.dcr/build-info.json` (`schemaVersion`, `artifact_path`, `profile`, …)
+  - `.dcr/toolchain.json` (compiler/debugger paths, moc/uic/rcc)
+  - `.dcr/ide/` (заготовки lock-файлов для расширений)
+- **`dcr gen project-info`** — поля `target`, `target_dir`, `artifact_path`, `artifact_kind`, `source_roots`, `include_globs`, `exclude_globs`; пути абсолютные/канонические.
+- **`dcr build --print-artifact-path`** — после успешной сборки одна строка absolute path на stdout.
+- **`dcr gen … --quiet` / `-q`** — без human-лога на stdout для `compile-commands` / `project-info`.
+- **`.clangd`** — при первом `gen` создаётся с `CompilationDatabase: .dcr` (маркер `# managed by dcr gen`); ручной `.clangd` не перезаписывается.
+- **Хелперы** `canonicalize_path`, `atomic_write`, `ensure_dcr_dir`; pure `resolve_artifact_path` через `platform::*`.
+- **`dcr new` / `dcr init`** — `.dcr/` в `.gitignore`.
+
+**Изменено (breaking):**
+
+- **`compile_commands.json` перенесён** из корня проекта в **`.dcr/compile_commands.json`**.  
+  clangd находит базу через `.clangd` / `clangd.arguments --compile-commands-dir=.dcr`.  
+  CLion `misc.xml` и VSCode `settings.json` обновлены под новый путь.
+- **Атомарная запись** `compile_commands.json` (tmp + rename).
+- **`gen vscode` / `gen clion` launch/run** — `program`/`executable` через тот же artifact resolver, что `project-info` / `build-info.json` (Linux triple, Windows `.exe`, custom `target`/`filename`).
+
+**Исправлено:**
+
+- Launch-конфиги больше не указывают `target/<profile>/<name>` без triple на Linux.
+- Симлинки/mount: root и пути в compile database канонизируются best-effort.
+
+### EN
+
+**Added:**
+
+- **`.dcr/` directory** — shared machine-readable build facts for IDE integrations:
+  - `.dcr/compile_commands.json`
+  - `.dcr/build-info.json` (`schemaVersion`, `artifact_path`, `profile`, …)
+  - `.dcr/toolchain.json` (compiler/debugger paths, moc/uic/rcc)
+  - `.dcr/ide/` (placeholder for IDE lock files)
+- **`dcr gen project-info`** — `target`, `target_dir`, `artifact_path`, `artifact_kind`, `source_roots`, `include_globs`, `exclude_globs`; absolute/canonical paths.
+- **`dcr build --print-artifact-path`** — one absolute artifact path line on stdout after a successful build.
+- **`dcr gen … --quiet` / `-q`** — suppress human success logs for gen subcommands.
+- **`.clangd`** — created on first gen with `CompilationDatabase: .dcr` (`# managed by dcr gen`); custom `.clangd` is not overwritten.
+- **Helpers** `canonicalize_path`, `atomic_write`, `ensure_dcr_dir`; pure `resolve_artifact_path` via `platform::*`.
+- **`dcr new` / `dcr init`** — add `.dcr/` to `.gitignore`.
+
+**Changed (breaking):**
+
+- **`compile_commands.json` moved** from project root to **`.dcr/compile_commands.json`**.  
+  clangd discovers it via `.clangd` / `--compile-commands-dir=.dcr`.  
+  CLion and VSCode generators updated accordingly.
+- **Atomic write** for compile_commands (tmp + rename).
+- **`gen vscode` / `gen clion` launch/run** — use the same artifact path resolver as `project-info` / `build-info.json`.
+
+**Fixed:**
+
+- Launch configs no longer hardcode `target/<profile>/<name>` without the Linux triple segment.
+- Symlink/mount roots: best-effort canonicalize for root and compile database paths.
+
+## [0.8.3] - 2026-08-03 "Конфигурация host target, аргументы run и нативные пути артефактов / Host Target Config, Run Args & Native Artifact Paths"
+
+### RU
+
+**Добавлено:**
+
+- **`dcr run -- <args>...`** — cargo-style: всё после bare `--` передаётся собранному бинарнику  
+  (`dcr run --release -- --test_help`). Работает и для прямого запуска, и для `[run].cmd`.
+- **Интеграционные / unit-тесты** — host target sections применяют `ldflags` без `--target`; проброс аргументов после `--`; парсер `split_double_dash`.
+
+**Изменено:**
+
+- **Native-сборка резолвит host triple** — без `--target` / без `build.target` конфиг-секции вида  
+  `[build.x86_64-unknown-linux-gnu]` (и аналоги host) снова применяются (`cflags` / `ldflags` / toolchain).  
+  Раньше target был «пустым», секции молча игнорировались, а артефакты уже лежали под host triple — линковка без `-L`/`-l`.
+- **Пустой target** — `normalize_target_os("")` больше не warn'ит `Unknown target ''`.
+- **`dcr run --help` / man `dcr-run`** — документирован разделитель `--` и forwarding args.
+
+**Исправлено:**
+
+- **Нативные пути артефактов на Windows и macOS** — без явного `--target` / `build.target` артефакты снова сохраняются в `target/<profile>`, поэтому `dcr run` и flat-bin находят результат сборки.
+- Target-specific `ldflags` на native Linux/macOS/Windows (host triple) не доходили до линкера.
+- Ложный warning на пустой target string.
+
+### EN
+
+**Added:**
+
+- **`dcr run -- <args>...`** — cargo-style: arguments after a bare `--` are forwarded to the built binary  
+  (`dcr run --release -- --test_help`). Works for direct binary runs and `[run].cmd`.
+- **Tests** — host target sections apply `ldflags` without CLI `--target`; run-arg forwarding; `split_double_dash` unit tests.
+
+**Changed:**
+
+- **Native builds resolve the host triple** — without `--target` / without package `build.target`, host sections such as  
+  `[build.x86_64-unknown-linux-gnu]` (and host equivalents) apply again (`cflags` / `ldflags` / toolchain).  
+  Previously the target was empty, those sections were silently ignored while artifacts already used the host triple path — link failed without `-L`/`-l` (e.g. sandbox micro-lang + `libsct-elf`).
+- **Empty target** — `normalize_target_os("")` no longer warns `Unknown target ''`.
+- **`dcr run --help` / man `dcr-run`** — document `--` and argument forwarding.
+
+**Fixed:**
+
+- **Native artifact paths on Windows and macOS** — without an explicit `--target` / `build.target`, artifacts again use `target/<profile>`, so `dcr run` and flat-bin find the build output.
+- Target-specific `ldflags` on native host builds not reaching the linker.
+- Spurious warning for an empty target string.
+
+## [0.8.2] - 2026-07-22 "CLI Progress, archive Feature, Workspace Path Fixes / CLI Progress, archive Feature, Workspace Path Fixes"
+
+### RU
+
+**Добавлено:**
+
+- **Прогресс компиляции `[N/M]`** — live-строка `compile  pkg v0.1.0  [12/41]` на TTY (stderr), чтобы длинные mono-package сборки не выглядели «зависшими».
+- **Свой стиль статуса build** — фиксированная колонка глаголов: `project`, `compile`, `dep`, `ready`, `pack`, `done`, `run` (не cargo-clone).
+- **Cargo feature `archive`** — `fatfs` и упаковка FAT-образов опциональны (`cargo build --features archive`). Release CI собирает с feature; без feature `[archive]` даёт явную ошибку.
+- **Интеграционные тесты** — `flat_bin_nasm_build`, `package_build_target_used_without_cli_flag`, усилен workspace `clean --all`.
+- **Расширенный CI** — unit + integration на Linux/macOS/Windows, отдельный job с `--features archive`, rust-cache, clippy default + all-features.
+
+**Изменено:**
+
+- **CLI host triple больше не форсится** — без `--target` используется `build.target` пакета/member (важно для bare-metal / post_steps ISO).
+- **Relative `-I`/`-L`/`-T` (и `-isystem`/`-idirafter`)** в cflags/ldflags абсолютизируются относительно корня пакета (workspace CWD = root).
+- **`dcr clean --all`** — не спамит `target not found` по members без локального `target/` (общий root `target/`).
+- **`error` / `warn`** — красный / жёлтый, вывод на stderr; `Подсказка:` → `Hint:`.
+- **`dcr --help` / man** — добавлены `add`, `lint`, `setup`; unknown command → exit code 1.
+- **Сообщения NotFound** — `linker not found: ld.lld …` / `{tool} not found …` вместо сырого `os error 2`.
+
+### EN
+
+**Added:**
+
+- **Compile progress `[N/M]`** — live TTY line `compile  pkg v0.1.0  [12/41]` so long mono-package builds do not look hung.
+- **DCR status verbs** — fixed-width column: `project`, `compile`, `dep`, `ready`, `pack`, `done`, `run`.
+- **Cargo feature `archive`** — optional `fatfs` / FAT packing (`cargo build --features archive`). Release CI builds with the feature; without it `[archive]` errors clearly.
+- **Integration tests** — `flat_bin_nasm_build`, package `build.target` without CLI flag, stricter workspace `clean --all`.
+- **Expanded CI** — unit + integration on Linux/macOS/Windows, archive feature job, rust-cache, clippy default + all-features.
+
+**Changed:**
+
+- **CLI no longer forces host triple** — without `--target`, package/member `build.target` is used (bare-metal / ISO post_steps).
+- **Relative `-I`/`-L`/`-T` (and `-isystem`/`-idirafter`)** in flags are absolutized against the package root when workspace CWD is the root.
+- **`dcr clean --all`** — no spam for members without a local `target/` (shared root `target/`).
+- **`error` / `warn`** — red / yellow on stderr; Russian `Подсказка:` → `Hint:`.
+- **`dcr --help` / man** — list `add`, `lint`, `setup`; unknown command exits 1.
+- **NotFound messages** — `linker not found: ld.lld …` / `{tool} not found …` instead of raw `os error 2`.
+
+## [0.8.1] - 2026-07-20 "OS-Dev: flat-bin, FAT-образы / OS-Dev: flat-bin & FAT Images"
+
+### RU
+
+**Добавлено:**
+
+- **`build.kind = "flat-bin"`** — сырой бинарный артефакт (расширение по умолчанию `.bin`):
+  - **NASM** — `-f bin`, прямой вывод `<stem>.bin`
+  - **FASM** — прямой вывод (ожидается `format binary` в исходнике)
+  - **GAS / MASM / LLVM IR (`llc`)** — объект → `objcopy -O binary` → `<stem>.bin`
+  - **C/C++ (gcc/clang/MSVC)** — compile → link (nostdlib/static) → `objcopy -O binary` → `<name>.bin`
+  - Требуется `llvm-objcopy` / `objcopy` / `gobjcopy` в PATH (кроме NASM/FASM direct)
+- **Секция `[archive]`** — после успешной сборки DCR собирает образ диска (FAT12/16/32): размер, offset, volume label, опциональный bootsector и `layout`. С 0.8.2 — за feature `archive`.
+- **Одиночные файлы в `build.roots`** — корень может быть файлом (`.c`, `.asm`, header), а не только каталогом.
+
+**Изменено:**
+
+- **`dcr build --force` / `dcr run --force`** — force также перезапускает `build.steps` и `build.post_steps`.
+- **`dcr run` на workspace-only root** — если задан `[run].cmd`, сначала build + run по конфигу корня; иначе делегирование члену workspace.
+
+### EN
+
+**Added:**
+
+- **`build.kind = "flat-bin"`** — raw binary (default `.bin`) across NASM/FASM/GAS/MASM/LLC and C/C++ (objcopy where needed).
+- **`[archive]` section** — FAT12/16/32 disk images after build (from 0.8.2 gated by feature `archive`).
+- **Single-file `build.roots`**.
+
+**Changed:**
+
+- **`--force`** re-runs steps/post_steps; workspace-only **`dcr run`** prefers root `[run].cmd` when set.
+
 ## [0.8.0] - 2026-07-18 "Модульный Движок Сборки, Новая Архитектура Ядра и Улучшение Workspaces / Modular Build Engine, New Core Architecture, & Workspace Improvements"

 ### RU
@@ -143,25 +347,31 @@
 ### RU

 **Добавлено:**
+
 - Учтён `target_env` в `default_target_triple()` — Linux (gnu/musl) и Windows (msvc/gnu) теперь используют правильное окружение, а не хардкод.

 **Исправлено:**
+
 - **Сборка на macOS Apple Silicon падала с `_main` undefined** — `--target=` теперь передаётся и в ldflags, не только в cflags. `default_target_triple()` на macOS использует `std::env::consts::ARCH` вместо хардкода `x86_64`.
 - **Бейджи GitHub Stars и GPL-3.0 не рендерились в README** — блок бейджей переведён на чистый HTML.

 **Изменено:**
+
 - Вычисление таргета по умолчанию вынесено в общую функцию `default_target_triple()` — устранено дублирование в build, run, clean.

 ### EN

 **Added:**
+
 - `default_target_triple()` now respects `target_env` — Linux (gnu/musl) and Windows (msvc/gnu) use the correct environment instead of hardcoded values.

 **Fixed:**
+
 - **macOS Apple Silicon builds failed with `_main` undefined** — `--target=` is now passed to ldflags, not just cflags. `default_target_triple()` uses `std::env::consts::ARCH` on macOS instead of hardcoded `x86_64`.
 - **GitHub Stars and GPL-3.0 badges not rendering in README** — badge block converted to pure HTML.

 **Changed:**
+
 - Default target resolution extracted into shared `default_target_triple()` — removed duplication across build, run, clean.

 ## [0.7.1] - 2026-06-02 "Мультиархитектурное расширение / The Multi-Arch Expansion"
@@ -169,6 +379,7 @@
 ### RU

 **Добавлено:**
+
 - Вывод `--help` для всех команд с цветным форматированием.
 - man-страницы (12 штук в `man/man1/`) и их установка во всех пакетах.
 - Валидация имен проектов в `dcr init` и `dcr new` (только ASCII буквы, цифры, `_` и `-`).
@@ -179,6 +390,7 @@
 - Пакеты AUR (`dcr-dev`, `dcr-dev-bin`) и сборка Snap в CI.

 **Изменено:**
+
 - Функция `validate_package_name` стала публичной.
 - Команды `gen`, `tree`, `fmt`, `setup` больше не игнорируют аргументы и используют цветной вывод.
 - Инструкция в README изменена с `| bash` на `| sh` для POSIX.
@@ -196,6 +408,7 @@
 ### EN

 **Added:**
+
 - `--help` for all commands with styled headers and usage lines.
 - Man pages (12 troff man pages in `man/man1/`) and their installation across all packaging formats.
 - Project name validation in `dcr init` and `dcr new` (ASCII letters, digits, `_`, `-` only).
@@ -206,6 +419,7 @@
 - AUR packages (`dcr-dev`, `dcr-dev-bin`) and Snap build in CI.

 **Changed:**
+
 - `validate_package_name` made public and callable from CLI commands directly.
 - `gen.rs`, `tree.rs`, `fmt.rs`, `setup.rs` no longer ignore arguments and use styled output.
 - README install instructions changed from `| bash` to `| sh` for POSIX compatibility.
@@ -382,6 +596,7 @@ Added:
  ```

  Produces `KERNEL.EFI` (works for `bin`, `staticlib`, and `sharedlib`).
+
 - Automatic injection of `--target=<build.target>` into compiler flags when `build.target` is set in `dcr.toml`. This greatly simplifies clang-based cross-compilation (especially for bare-metal targets like `aarch64-none-elf`).
 - Bare-metal targets (containing `none`, `-elf`, `eabi`, `baremetal`) no longer receive DCR's internal default flags (`-g`, `-Wall`, `-Wextra`, `-fno-omit-frame-pointer`, `-DDCR_DEBUG`, etc.). Prevents unwanted sections (`.comment`, debug info, etc.) that break custom linker scripts when `inherit = true`.
 - `build.ldscript` in `dcr.toml` — linker script path passed as `-T <path>` to the linker. Essential for bare-metal/embedded/freestanding targets.
@@ -416,28 +631,28 @@ Fixed:

 - Path dependencies now work correctly: `dcr add` stores them as `{ path =
 "./..." }` tables, `is_registry_dep` properly distinguishes registry strings
-from path/git strings, and `deps/mod.rs` resolves both table-form and
-legacy string-form path dependencies
+  from path/git strings, and `deps/mod.rs` resolves both table-form and
+  legacy string-form path dependencies
 - Registry dependency paths no longer hardcoded to `project_root/dcr-index`;
-now use `package_root_from_registry_info()` which resolves relative to the
-registry cache root (`~/.dcr/`)
+  now use `package_root_from_registry_info()` which resolves relative to the
+  registry cache root (`~/.dcr/`)
 - Registry dependencies are now actually built: `build_project_at()` is
-called when `include_dir` or `lib_dir` is missing
+  called when `include_dir` or `lib_dir` is missing

 Added:

 - `SIGINT`/`Ctrl+C` handler via `ctrlc` crate — `dcr build` now checks
-`BUILD_INTERRUPTED` flag at key points and aborts cleanly
+  `BUILD_INTERRUPTED` flag at key points and aborts cleanly
 - `utils/build.rs` — extracted shared utilities: `parse_version_info`,
-`normalize_target_os`, `resolve_compiler`, `primary_language`,
-`resolve_pkg_config_flags` and config helpers. Eliminates code duplication
-between `cli/build.rs`, `cli/run.rs`, `cli/clean.rs`, `cli/gen.rs`
+  `normalize_target_os`, `resolve_compiler`, `primary_language`,
+  `resolve_pkg_config_flags` and config helpers. Eliminates code duplication
+  between `cli/build.rs`, `cli/run.rs`, `cli/clean.rs`, `cli/gen.rs`
 - `utils/fs.rs::with_dir` — extracted common directory-scoped execution
 - `run_command_sync_output` in `builder/common.rs` with global `OUTPUT_MUTEX`
-— synchronized compiler output across all backends (unix_cc, gas, nasm, msvc)
+  — synchronized compiler output across all backends (unix_cc, gas, nasm, msvc)
 - New helper functions in `deps/register.rs`: `get_registry_cache_root`,
-`package_root_from_registry_info`, `registry_include_dir`, `registry_lib_dir`,
-`path_from_string_dep`
+  `package_root_from_registry_info`, `registry_include_dir`, `registry_lib_dir`,
+  `path_from_string_dep`
 - Unit tests for `register.rs` (`is_registry_dep`, `package_root_from_registry_info`),
  `deps/mod.rs` (`path_dep_path`, `push_default_lib_dirs`),
  `utils/build.rs` (`normalize_target_os`, `parse_version_info`)
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,18 +2,39 @@
 # It is not intended for manual editing.
 version = 4

+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "anyhow"
 version = "1.0.102"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"

+[[package]]
+name = "autocfg"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
+
 [[package]]
 name = "base64"
 version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"

+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
 [[package]]
 name = "bitflags"
 version = "2.11.1"
@@ -38,6 +59,28 @@ dependencies = [
 "objc2",
 ]

+[[package]]
+name = "bumpalo"
+version = "3.20.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "cc"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c89588d05638b5b4594a3348a2d6c20277e43a7f5c5202b05cc56888475a47b8"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
 [[package]]
 name = "cfg-if"
 version = "1.0.4"
@@ -50,6 +93,19 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"

+[[package]]
+name = "chrono"
+version = "0.4.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1aa79e62e7697b8e29b513a68abacf485adcd1fe8284a4316c5ae868e6633327"
+dependencies = [
+ "iana-time-zone",
+ "js-sys",
+ "num-traits",
+ "wasm-bindgen",
+ "windows-link",
+]
+
 [[package]]
 name = "core-foundation"
 version = "0.9.4"
@@ -98,9 +154,10 @@ dependencies = [

 [[package]]
 name = "dcr"
-version = "0.8.0"
+version = "0.8.5"
 dependencies = [
 "ctrlc",
+ "fatfs",
 "glob",
 "self-replace",
 "serde",
@@ -127,7 +184,7 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e0e367e4e7da84520dedcac1901e4da967309406d1e51017ae1abfb97adbd38"
 dependencies = [
- "bitflags",
+ "bitflags 2.11.1",
 "block2",
 "libc",
 "objc2",
@@ -166,6 +223,24 @@ version = "2.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"

+[[package]]
+name = "fatfs"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05669f8e7e2d7badc545c513710f0eba09c2fbef683eb859fd79c46c355048e0"
+dependencies = [
+ "bitflags 1.3.2",
+ "byteorder",
+ "chrono",
+ "log",
+]
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+
 [[package]]
 name = "foldhash"
 version = "0.1.5"
@@ -181,6 +256,30 @@ dependencies = [
 "percent-encoding",
 ]

+[[package]]
+name = "futures-core"
+version = "0.3.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2cd50c473c80f6d7c3670a752354b8e569b1a7cbfdc0419ec88e5edad85e0dc7"
+
+[[package]]
+name = "futures-task"
+version = "0.3.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b231ed28831efb4a61a08580c4bc233ec56bc009f4cd8f52da2c3cb97df0c109"
+
+[[package]]
+name = "futures-util"
+version = "0.3.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a77a90a256fce34da66415271e30f94ee91c57b04b8a2c042d9cf3220179deaa"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "pin-project-lite",
+ "slab",
+]
+
 [[package]]
 name = "generic-array"
 version = "0.14.7"
@@ -231,6 +330,30 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"

+[[package]]
+name = "iana-time-zone"
+version = "0.1.65"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "log",
+ "wasm-bindgen",
+ "windows-core",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "icu_collections"
 version = "2.2.0"
@@ -358,6 +481,17 @@ version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"

+[[package]]
+name = "js-sys"
+version = "0.3.103"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53b44bfcdb3f8d5837a46dae1ca9660a837176eee74a28b229bc626816589102"
+dependencies = [
+ "cfg-if",
+ "futures-util",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "leb128fmt"
 version = "0.1.0"
@@ -400,12 +534,21 @@ version = "0.31.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf20d2fde8ff38632c426f1165ed7436270b44f199fc55284c38276f9db47c3d"
 dependencies = [
- "bitflags",
+ "bitflags 2.11.1",
 "cfg-if",
 "cfg_aliases",
 "libc",
 ]

+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
 [[package]]
 name = "objc2"
 version = "0.6.4"
@@ -439,6 +582,12 @@ version = "2.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"

+[[package]]
+name = "pin-project-lite"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
+
 [[package]]
 name = "potential_utf"
 version = "0.1.5"
@@ -488,7 +637,7 @@ version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
 dependencies = [
- "bitflags",
+ "bitflags 2.11.1",
 "errno",
 "libc",
 "linux-raw-sys",
@@ -526,6 +675,12 @@ dependencies = [
 "zeroize",
 ]

+[[package]]
+name = "rustversion"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
+
 [[package]]
 name = "schannel"
 version = "0.1.29"
@@ -541,7 +696,7 @@ version = "2.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
 dependencies = [
- "bitflags",
+ "bitflags 2.11.1",
 "core-foundation",
 "core-foundation-sys",
 "libc",
@@ -638,6 +793,18 @@ dependencies = [
 "digest",
 ]

+[[package]]
+name = "shlex"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
+
+[[package]]
+name = "slab"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
+
 [[package]]
 name = "smallvec"
 version = "1.15.1"
@@ -833,6 +1000,51 @@ dependencies = [
 "wit-bindgen 0.51.0",
 ]

+[[package]]
+name = "wasm-bindgen"
+version = "0.2.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b067c0c11094aef6b7a801c1e34a26affafdf3d051dba08456b868789aaf9a4"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "167ce5e579f6bcf889c4f7175a8a5a585de84e8ff93976ce393efa5f2837aab1"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3997c7839262f4ef12cf90b818d6340c18e80f263f1a94bf157d0ec4420380e"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc1b4cb0cc549fcf58d7dfc081778139b3d283a081644e833e84682ad71cea24"
+dependencies = [
+ "unicode-ident",
+]
+
 [[package]]
 name = "wasm-encoder"
 version = "0.244.0"
@@ -861,18 +1073,71 @@ version = "0.244.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
 dependencies = [
- "bitflags",
+ "bitflags 2.11.1",
 "hashbrown 0.15.5",
 "indexmap",
 "semver",
 ]

+[[package]]
+name = "windows-core"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link",
+ "windows-result",
+ "windows-strings",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "windows-link"
 version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"

+[[package]]
+name = "windows-result"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
+dependencies = [
+ "windows-link",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.52.0"
@@ -1034,7 +1299,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
 dependencies = [
 "anyhow",
- "bitflags",
+ "bitflags 2.11.1",
 "indexmap",
 "log",
 "serde",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "dcr"
-version = "0.8.0"
+version = "0.8.5"
 edition = "2024"
 build = "build.rs"
 description = "DCR is a utility for managing C/C++ projects in a Cargo-like style."
@@ -59,6 +59,10 @@ assets = [
    { source = "man/man1/dcr-tree.1", dest = "/usr/share/man/man1/dcr-tree.1", mode = "644" },
 ]

+[features]
+default = []
+archive = ["dep:fatfs"]
+
 [dependencies]
 glob = "0.3"
 ureq = { version = "2.10", default-features = false, features = ["json", "native-certs"] }
@@ -69,6 +73,7 @@ toml = "1.0.3"
 toml_edit = "0.22"
 serde_json = "1"
 ctrlc = "3"
+fatfs = { version = "0.3", optional = true }

 [profile.release]
 opt-level = "z"
--- a/README.md
+++ b/README.md
@@ -34,32 +34,6 @@

 <table>
 <tr>
-<td><b>Linux (Dexoron Packages)</b></td>
-<td>
-
-See https://pkg.dexoron.su for settings youre packages manager
-
-**Arch Linux:**
-
-```sh
-sudo pacman -Sy dcr
-```
-
-**Debian/Ubuntu:**
-
-```sh
-sudo apt update && sudo apt install dcr
-```
-
-**Fedora/RHEL:**
-
-```sh
-sudo dnf install dcr
-```
-
-</td>
-</tr>
-<tr>
 <td><b>Arch Linux (AUR)</b></td>
 <td>

@@ -103,21 +77,28 @@ cargo install dcr
 </td>
 </tr>
 <tr>
-<td><b>Linux / macOS (script)</b></td>
+<td><b>dcrup (Linux / macOS / BSD / Windows(Bash))</b></td>
 <td>

 ```sh
-curl -fsSL https://dcr.dexoron.su/install.sh | sh
+curl -fsSL https://sh.dcr-tool.ru | sh -s -- self-install
+export PATH="$HOME/.dcr/bin:$PATH"
+dcrup install stable
 ```

 </td>
 </tr>
 <tr>
-<td><b>BSD (script)</b></td>
+<td><b>dcrup (Windows PowerShell)</b></td>
 <td>

-```sh
-curl -fsSL https://dcr.dexoron.su/install_bsd.sh | sh
+```powershell
+irm https://ps1.dcr-tool.ru | iex
+# or:
+# irm https://ps1.dcr-tool.ru -OutFile dcrup.ps1
+# powershell -File .\dcrup.ps1 self-install
+# $env:Path += ";$env:USERPROFILE\.dcr\bin"
+dcrup install stable
 ```

 </td>
@@ -133,16 +114,6 @@ curl -fsSL https://dcr.dexoron.su/install_bsd.sh | sh
 sudo snap install --classic --dangerous dcrup_*.snap
 ```

-</td>
-</tr>
-<tr>
-<td><b>Windows (PowerShell)</b></td>
-<td>
-
-```powershell
-irm https://dcr.dexoron.su/install.ps1 | iex
-```
-
 </td>
 </tr>
 <tr>
@@ -151,7 +122,7 @@ irm https://dcr.dexoron.su/install.ps1 | iex

 ```sh
 git clone https://github.com/dexoron/dcr.git
-cd dcr && cargo build --release
+cd dcr && cargo build --release --features archive
 ln -sf "$PWD/target/release/dcr" ~/.local/bin/dcr
 ```

--- a/TODO.md
+++ b/TODO.md
@@ -1,65 +0,0 @@
-# DCR TODO.md
-
-Priority list of tasks to turn DCR into a true Cargo killer for C/C++ developers.
-
-**Legend:** `[ ]` — not implemented | `[-]` — partially implemented | `[x]` — implemented
-
-## 🔥 High Priority
-
- [ ] **CLI Output Refactoring & Cleanup**
-  - [ ] Move all terminal strings to a dedicated module (`src/ui/messages.rs`)
-  - [ ] Standardize logging formats (`error:`, `warning:`, `status:`)
-  - [x] Add build execution time statistics to the final output (e.g., `Finished in 4.23s`)
- [ ] **Internationalization (i18n) / Localization**
-  - [ ] Integrate a lightweight localization engine (`fluent` or `gettext` pure-Rust port)
-  - [ ] Create initial translation catalogs (`en.ftl`, `ru.ftl`)
- [x] **Self-Update Stability Validation**
-  - [x] Self-update implemented via `self-replace` + `ureq` in `flag_update.rs`
- [-] **Freestanding / Embedded Automation**
-  - *`-ffreestanding` injected at compile time, `-nostdlib -static` at link time for bare-metal targets or `build.freestanding = true`. Config option `build.freestanding` (bool) added.*
- [ ] **Conan and vcpkg integration** Automatic download, installation and linking of packages
-
-## ✅ Medium Priority
-
- [ ] **Static analysis** (`dcr check`)  
-  Integration with clang-tidy, cppcheck, include-what-you-use
- [x] **Linter + Formatter** (`dcr fmt`, `dcr lint`)  
-  *`dcr fmt` (clang-format) and `dcr lint` (clang-tidy) are implemented*
- [ ] **Hot reload / Live reload** for applications (raylib, SFML, SDL, etc.)
- [-] **Workspaces improvements** Per-member include directories, selective builds, better dependency graph  
-  *Basic workspaces with dep ordering + topological sort work; advanced features missing*
- [-] **Build-time code generation** Support for protobuf, flatbuffers, Qt moc, custom generators  
-  *Generic `build.steps` machinery + Qt toolchain (uic/moc/rcc) work; no dedicated protobuf/flatbuffers generators*
- [-] **dcr publish + official package registry** *Registry consumption (fetch, resolve, link) works; `dcr publish` command / local packing missing*
-
-## 📌 Low Priority / Nice to Have
-
- [ ] Support for Meson and Ninja as alternative backends
- [ ] Dockerfile generation (`dcr docker init`)
- [ ] First-class Windows MSVC support (currently works but rough)
- [ ] Documentation generation (`dcr doc`)
- [ ] Sanitizers integration (`dcr sanitize`)
- [ ] Benchmarks and comparison with CMake/Meson
- [ ] C++20 modules support (when it becomes stable)
-
-## 🧠 Future Ideas
-
- Official DCR package registry (dcrhub)
- GUI wrapper (dcr-gui)
- Plugin system
- Toolchain manager (like rustup)
- Zig as alternative compiler
- deb/rpm/flatpak/AppImage packaging support
-
---
-
-**Currently in progress:**
- UI/UX terminal output unification and benchmarking metrics.
-
-**Completed in recent releases:**
- Extreme binary size optimization (-50% weight reduction via `ureq` + `native-certs`)
- Complete removal of `git2` and `openssl` in favor of system Git execution
- Workspaces & Cross-compilation (`--target <triple>`)
- IDE config generation (VS Code, CLion, compile_commands.json)
- EFI support & Linker script support (`build.ldscript`)
- Mixed C/C++/ASM compilation with custom `std::thread::scope` work-stealing engine
--- a/crowdin.yml
+++ b/crowdin.yml
@@ -0,0 +1,3 @@
+files:
+  - source: /docs/**/*.mdx
+    translation: /docs-crowdin-export/%locale%/%original_path%/%original_file_name%.%file_extension%
--- a/dcrup.cmd
+++ b/dcrup.cmd
@@ -0,0 +1,13 @@
+@echo off
+setlocal
+set "SCRIPT_DIR=%~dp0"
+if exist "%SCRIPT_DIR%dcrup.ps1" (
+  powershell -NoProfile -ExecutionPolicy Bypass -File "%SCRIPT_DIR%dcrup.ps1" %*
+  exit /b %ERRORLEVEL%
+)
+if exist "%USERPROFILE%\.dcr\bin\dcrup.ps1" (
+  powershell -NoProfile -ExecutionPolicy Bypass -File "%USERPROFILE%\.dcr\bin\dcrup.ps1" %*
+  exit /b %ERRORLEVEL%
+)
+echo [error] dcrup.ps1 not found near dcrup.cmd >&2
+exit /b 1
--- a/dcrup.ps1
+++ b/dcrup.ps1
@@ -0,0 +1,367 @@
+#Requires -Version 5.1
+$ErrorActionPreference = 'Stop'
+
+$DcrupHome = if ($env:DCRUP_HOME) { $env:DCRUP_HOME } else { Join-Path $env:USERPROFILE '.dcr' }
+$DcrupBin  = if ($env:DCRUP_BIN)  { $env:DCRUP_BIN  } else { Join-Path $DcrupHome 'bin' }
+$DcrupTc   = Join-Path $DcrupHome 'toolchains'
+$DcrupMeta = Join-Path $DcrupHome 'meta'
+$RepoUrl   = if ($env:DCRUP_REPO) { $env:DCRUP_REPO } else { 'https://github.com/dexoron/dcr' }
+$ApiLatest = 'https://api.github.com/repos/dexoron/dcr/releases/latest'
+$ApiAll    = 'https://api.github.com/repos/dexoron/dcr/releases'
+$Features  = if ($env:DCR_FEATURES) { $env:DCR_FEATURES } else { 'archive' }
+
+function Info($m) { Write-Host "[dcrup] $m" -ForegroundColor Cyan }
+function Ok($m)   { Write-Host "[ok] $m" -ForegroundColor Green }
+function Warn($m) { Write-Host "[warn] $m" -ForegroundColor Yellow }
+function Die($m)  { Write-Host "[error] $m" -ForegroundColor Red; exit 1 }
+
+function Show-Usage {
+    @'
+dcrup — install and switch DCR versions (Windows)
+
+Usage:
+  dcrup install <spec> [--build|--release] [--force]
+  dcrup default <spec>
+  dcrup update
+  dcrup list
+  dcrup show
+  dcrup which
+  dcrup uninstall [<spec>|--all]
+  dcrup self-install [--to DIR]
+  dcrup help
+
+Spec:
+  stable | dev | night
+  VERSION              → VERSION@stable  (e.g. 0.8.2)
+  VERSION@stable
+  VERSION@dev
+  night                → always build from branch "dev" HEAD
+
+Modes:
+  --release   download GitHub Release binary (default for stable/dev)
+  --build     cargo build --release --features archive
+  night       always --build (prebuilt not available)
+
+Env:
+  DCRUP_HOME      default ~/.dcr
+  DCRUP_BIN       default $DCRUP_HOME/bin
+  DCR_FEATURES    default archive
+  DCRUP_REPO      git/GitHub repo URL
+'@ | Write-Host
+}
+
+function Ensure-Dirs {
+    New-Item -ItemType Directory -Force -Path $DcrupTc, $DcrupBin, $DcrupMeta | Out-Null
+}
+
+function Get-Target {
+    $arch = $env:PROCESSOR_ARCHITECTURE
+    if ($env:PROCESSOR_ARCHITEW6432) { $arch = $env:PROCESSOR_ARCHITEW6432 }
+    switch ($arch) {
+        'AMD64' { return 'x86_64-pc-windows-msvc' }
+        'ARM64' { return 'aarch64-pc-windows-msvc' }
+        'x86'   { return 'i686-pc-windows-msvc' }
+        default { Die "unsupported arch: $arch" }
+    }
+}
+
+function Normalize-Version([string]$v) {
+    if ($v.StartsWith('v')) { return $v.Substring(1) }
+    return $v
+}
+
+function Parse-Spec([string]$raw) {
+    $script:SpecRaw = $raw
+    $script:SpecChannel = $null
+    $script:SpecVersion = $null
+    $script:SpecFloating = $false
+
+    if ($raw -in @('stable', 'dev', 'night')) {
+        $script:SpecChannel = $raw
+        $script:SpecFloating = $true
+        return
+    }
+    if ($raw -match '^(.*)@(.*)$') {
+        $script:SpecVersion = Normalize-Version $Matches[1]
+        $script:SpecChannel = $Matches[2]
+        if ($script:SpecChannel -eq 'night') { Die 'cannot pin version on night' }
+        if ($script:SpecChannel -notin @('stable', 'dev')) { Die "unknown channel: $($script:SpecChannel)" }
+        return
+    }
+    $script:SpecVersion = Normalize-Version $raw
+    $script:SpecChannel = 'stable'
+}
+
+function Toolchain-Id([string]$extra = '') {
+    if ($script:SpecChannel -eq 'night') {
+        return "night-$extra"
+    }
+    if ($script:SpecFloating) {
+        return "$($script:SpecChannel)-$extra"
+    }
+    return "$($script:SpecVersion)-$($script:SpecChannel)"
+}
+
+function Active-Path { Join-Path $DcrupMeta 'active' }
+
+function Read-Active {
+    $p = Active-Path
+    if (Test-Path $p) { return (Get-Content $p -Raw).Trim() }
+    return $null
+}
+
+function Write-Active([string]$id) {
+    Set-Content -Path (Active-Path) -Value $id -NoNewline
+}
+
+function Link-Default([string]$id) {
+    $src = Join-Path (Join-Path $DcrupTc $id) 'dcr.exe'
+    if (-not (Test-Path $src)) { Die "toolchain not installed: $id" }
+    $dst = Join-Path $DcrupBin 'dcr.exe'
+    Copy-Item $src $dst -Force
+    Write-Active $id
+    Ok "default → $id ($dst)"
+}
+
+function Fetch-Release($channel, $version) {
+    if ($version) {
+        return Invoke-RestMethod -Uri "https://api.github.com/repos/dexoron/dcr/releases/tags/v$version"
+    }
+    if ($channel -eq 'dev') {
+        $all = Invoke-RestMethod -Uri $ApiAll
+        $pre = $all | Where-Object { $_.prerelease } | Select-Object -First 1
+        if (-not $pre) { Die 'no prerelease (dev) found' }
+        return $pre
+    }
+    return Invoke-RestMethod -Uri $ApiLatest
+}
+
+function Install-Prebuilt([switch]$Force) {
+    $triple = Get-Target
+    $rel = Fetch-Release $script:SpecChannel $script:SpecVersion
+    $tag = $rel.tag_name
+    $ver = Normalize-Version $tag
+    $assetName = "dcr-$triple-$ver.exe"
+    $asset = $rel.assets | Where-Object { $_.name -eq $assetName } | Select-Object -First 1
+    if (-not $asset) { Die "asset not found: $assetName" }
+
+    $id = if ($script:SpecFloating) { Toolchain-Id $ver } else { Toolchain-Id }
+    $dest = Join-Path $DcrupTc $id
+    $bin = Join-Path $dest 'dcr.exe'
+    if ((Test-Path $bin) -and -not $Force) {
+        Ok "already installed: $id"
+        Link-Default $id
+        return
+    }
+    Ensure-Dirs
+    New-Item -ItemType Directory -Force -Path $dest | Out-Null
+    Info "downloading $assetName …"
+    Invoke-WebRequest -Uri $asset.browser_download_url -OutFile $bin
+    @"
+channel=$($script:SpecChannel)
+version=$ver
+tag=$tag
+source=release
+triple=$triple
+"@ | Set-Content (Join-Path $dest 'dcrup-meta')
+    Ok "installed prebuilt $id"
+    Link-Default $id
+}
+
+function Install-Build([switch]$Force) {
+    if (-not (Get-Command git -ErrorAction SilentlyContinue)) { Die 'git not found' }
+    if (-not (Get-Command cargo -ErrorAction SilentlyContinue)) { Die 'cargo not found' }
+
+    $tmp = Join-Path $env:TEMP ("dcrup-" + [guid]::NewGuid().ToString('N'))
+    New-Item -ItemType Directory -Path $tmp | Out-Null
+    try {
+        $src = Join-Path $tmp 'src'
+        if ($script:SpecChannel -eq 'night') {
+            Info "cloning dev for night …"
+            git clone --depth 1 --branch dev $RepoUrl $src 2>$null
+            if ($LASTEXITCODE -ne 0) { git clone --depth 1 $RepoUrl $src | Out-Null }
+            $sha = (git -C $src rev-parse --short HEAD).Trim()
+            $id = Toolchain-Id $sha
+            $ver = 'night'
+        } elseif ($script:SpecFloating) {
+            $rel = Fetch-Release $script:SpecChannel $null
+            $tag = $rel.tag_name
+            $ver = Normalize-Version $tag
+            $id = Toolchain-Id $ver
+            Info "cloning $tag …"
+            git clone --depth 1 --branch $tag $RepoUrl $src 2>$null
+            if ($LASTEXITCODE -ne 0) {
+                git clone --depth 1 $RepoUrl $src | Out-Null
+                git -C $src fetch --depth 1 origin "refs/tags/${tag}:refs/tags/${tag}"
+                git -C $src checkout $tag
+            }
+            $sha = (git -C $src rev-parse --short HEAD).Trim()
+        } else {
+            $tag = "v$($script:SpecVersion)"
+            $ver = $script:SpecVersion
+            $id = Toolchain-Id
+            Info "cloning $tag …"
+            git clone --depth 1 --branch $tag $RepoUrl $src 2>$null
+            if ($LASTEXITCODE -ne 0) {
+                git clone --depth 1 $RepoUrl $src | Out-Null
+                git -C $src fetch --depth 1 origin "refs/tags/${tag}:refs/tags/${tag}"
+                git -C $src checkout $tag
+            }
+            $sha = (git -C $src rev-parse --short HEAD).Trim()
+        }
+
+        $dest = Join-Path $DcrupTc $id
+        $bin = Join-Path $dest 'dcr.exe'
+        if ((Test-Path $bin) -and -not $Force) {
+            Ok "already installed: $id"
+            Link-Default $id
+            return
+        }
+
+        $triple = Get-Target
+        Info "building release (features: $Features) …"
+        Push-Location $src
+        cargo build --release --features $Features --target $triple
+        if ($LASTEXITCODE -ne 0) { Die 'cargo build failed' }
+        Pop-Location
+
+        New-Item -ItemType Directory -Force -Path $dest | Out-Null
+        Copy-Item (Join-Path $src "target\$triple\release\dcr.exe") $bin -Force
+        @"
+channel=$($script:SpecChannel)
+version=$ver
+git=$sha
+source=build
+features=$Features
+"@ | Set-Content (Join-Path $dest 'dcrup-meta')
+        Ok "installed build $id"
+        Link-Default $id
+    } finally {
+        Remove-Item -Recurse -Force $tmp -ErrorAction SilentlyContinue
+    }
+}
+
+function Ensure-UserPath {
+    $userPath = [Environment]::GetEnvironmentVariable('Path', 'User')
+    if (-not $userPath) { $userPath = '' }
+    if (-not ($userPath -split ';' | Where-Object { $_ -eq $DcrupBin })) {
+        $new = if ($userPath) { "$userPath;$DcrupBin" } else { $DcrupBin }
+        [Environment]::SetEnvironmentVariable('Path', $new, 'User')
+        $env:Path = "$env:Path;$DcrupBin"
+        Warn "added to user PATH: $DcrupBin (restart shell if needed)"
+    }
+}
+
+function Install-CmdShim {
+    $cmd = Join-Path $DcrupBin 'dcrup.cmd'
+    $ps1 = Join-Path $DcrupBin 'dcrup.ps1'
+    @"
+@echo off
+setlocal
+powershell -NoProfile -ExecutionPolicy Bypass -File "%~dp0dcrup.ps1" %*
+"@ | Set-Content -Path $cmd -Encoding ASCII
+    if (-not (Test-Path $ps1)) {
+        Copy-Item $PSCommandPath $ps1 -Force
+    }
+}
+
+function Cmd-Install {
+    param([string[]]$Args)
+    $mode = 'release'
+    $force = $false
+    $spec = $null
+    foreach ($a in $Args) {
+        switch -Regex ($a) {
+            '^--build$' { $mode = 'build'; continue }
+            '^--release$' { $mode = 'release'; continue }
+            '^--force$' { $force = $true; continue }
+            '^-' { Die "unknown flag: $a" }
+            default {
+                if ($spec) { Die "unexpected: $a" }
+                $spec = $a
+            }
+        }
+    }
+    if (-not $spec) { Die 'usage: dcrup install <spec> [--build|--release] [--force]' }
+    Parse-Spec $spec
+    Ensure-Dirs
+    if ($script:SpecChannel -eq 'night') { $mode = 'build' }
+    Info "install spec=$spec channel=$($script:SpecChannel) mode=$mode"
+    if ($mode -eq 'build') { Install-Build -Force:$force } else { Install-Prebuilt -Force:$force }
+    Ensure-UserPath
+    Install-CmdShim
+}
+
+function Cmd-List {
+    Ensure-Dirs
+    $active = Read-Active
+    Get-ChildItem $DcrupTc -Directory -ErrorAction SilentlyContinue | ForEach-Object {
+        $mark = if ($_.Name -eq $active) { ' *' } else { '  ' }
+        Write-Host "$mark $($_.Name)"
+    }
+}
+
+function Cmd-Show {
+    Ensure-Dirs
+    Write-Host "DCRUP_HOME=$DcrupHome"
+    Write-Host "DCRUP_BIN=$DcrupBin"
+    Write-Host "active=$(Read-Active)"
+    $exe = Join-Path $DcrupBin 'dcr.exe'
+    if (Test-Path $exe) { & $exe --version }
+}
+
+function Cmd-SelfInstall {
+    Ensure-Dirs
+    Copy-Item $PSCommandPath (Join-Path $DcrupBin 'dcrup.ps1') -Force
+    Install-CmdShim
+    Ensure-UserPath
+    Ok "dcrup installed to $DcrupBin (use: dcrup …)"
+}
+
+$cmd = if ($args.Count -ge 1) { $args[0] } else { 'help' }
+$rest = @()
+if ($args.Count -gt 1) { $rest = $args[1..($args.Count - 1)] }
+
+switch ($cmd) {
+    { $_ -in @('help', '-h', '--help') } { Show-Usage }
+    'install' { Cmd-Install $rest }
+    'list' { Cmd-List }
+    'show' { Cmd-Show }
+    'which' {
+        $p = Join-Path $DcrupBin 'dcr.exe'
+        if (Test-Path $p) { $p } else { Die 'dcr not installed' }
+    }
+    'default' {
+        if ($rest.Count -ne 1) { Die 'usage: dcrup default <spec>' }
+        Parse-Spec $rest[0]
+        if ($script:SpecFloating -or $script:SpecChannel -eq 'night') {
+            $id = Get-ChildItem $DcrupTc -Directory |
+                Where-Object { $_.Name -like "$($script:SpecChannel)-*" } |
+                Sort-Object Name | Select-Object -Last 1
+            if (-not $id) { Die "not installed: $($rest[0])" }
+            Link-Default $id.Name
+        } else {
+            Link-Default (Toolchain-Id)
+        }
+    }
+    'update' {
+        $a = Read-Active
+        if (-not $a) { Die 'no active toolchain' }
+        if ($a -like 'night-*') { Cmd-Install @('night', '--build', '--force') }
+        elseif ($a -like 'stable-*') { Cmd-Install @('stable', '--force') }
+        elseif ($a -like 'dev-*') { Cmd-Install @('dev', '--force') }
+        else { Ok "pinned $a — install a newer version explicitly" }
+    }
+    'uninstall' {
+        if ($rest -contains '--all') {
+            Remove-Item -Recurse -Force $DcrupTc -ErrorAction SilentlyContinue
+            Remove-Item (Join-Path $DcrupBin 'dcr.exe') -ErrorAction SilentlyContinue
+            Remove-Item (Active-Path) -ErrorAction SilentlyContinue
+            Ok 'removed all'
+        } else {
+            Die 'use: dcrup uninstall --all  (or install a replacement first)'
+        }
+    }
+    'self-install' { Cmd-SelfInstall }
+    default { Die "unknown command: $cmd" }
+}
--- a/dcrup.sh
+++ b/dcrup.sh
@@ -0,0 +1,599 @@
+#!/usr/bin/env bash
+set -Eeuo pipefail
+
+DCRUP_HOME="${DCRUP_HOME:-$HOME/.dcr}"
+DCRUP_BIN="${DCRUP_BIN:-$DCRUP_HOME/bin}"
+DCRUP_TC="${DCRUP_HOME}/toolchains"
+DCRUP_META="${DCRUP_HOME}/meta"
+REPO_URL="${DCRUP_REPO:-https://github.com/dexoron/dcr}"
+API_LATEST="https://api.github.com/repos/dexoron/dcr/releases/latest"
+API_ALL="https://api.github.com/repos/dexoron/dcr/releases"
+FEATURES="${DCR_FEATURES:-archive}"
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+CYAN='\033[0;36m'
+NC='\033[0m'
+
+log()  { printf "${CYAN}[dcrup]${NC} %s\n" "$*"; }
+ok()   { printf "${GREEN}[ok]${NC} %s\n" "$*"; }
+warn() { printf "${YELLOW}[warn]${NC} %s\n" "$*"; }
+die()  { printf "${RED}[error]${NC} %s\n" "$*" >&2; exit 1; }
+
+usage() {
+    cat <<'EOF'
+dcrup — install and switch DCR versions
+
+Usage:
+  dcrup install <spec> [--build|--release] [--force] [--libc gnu|musl|auto]
+  dcrup default <spec>
+  dcrup update
+  dcrup list
+  dcrup show
+  dcrup which
+  dcrup uninstall [<spec>|--all]
+  dcrup self-install [--to DIR]
+  dcrup help
+
+Spec:
+  stable | dev | night
+  VERSION              → VERSION@stable  (e.g. 0.8.2)
+  VERSION@stable
+  VERSION@dev
+  night                → always build from branch "dev" HEAD
+
+Modes:
+  --release   download GitHub Release binary (default for stable/dev)
+  --build     cargo build --release --features archive
+  night       always --build (prebuilt not available)
+
+Linux libc (prebuilt triple only):
+  --libc gnu    x86_64-unknown-linux-gnu (default)
+  --libc musl   x86_64-unknown-linux-musl
+  --libc auto   musl if host ldd/libc is musl, else gnu
+
+Env:
+  DCRUP_HOME      default ~/.dcr
+  DCRUP_BIN       default $DCRUP_HOME/bin
+  DCR_FEATURES    default archive
+  DCRUP_REPO      git/GitHub repo URL
+  DCRUP_LIBC      gnu|musl|auto (default: gnu)
+EOF
+}
+
+need_cmd() {
+    command -v "$1" >/dev/null 2>&1 || die "required command not found: $1"
+}
+
+detect_linux_libc() {
+    local pref="${DCRUP_LIBC:-gnu}"
+    case "$pref" in
+        gnu|glibc) echo "gnu" ;;
+        musl) echo "musl" ;;
+        auto)
+            if command -v ldd >/dev/null 2>&1; then
+                if ldd --version 2>&1 | grep -qi musl; then
+                    echo "musl"
+                    return 0
+                fi
+            fi
+            if [[ -e /lib/ld-musl-x86_64.so.1 || -e /lib/ld-musl-aarch64.so.1 ]]; then
+                echo "musl"
+                return 0
+            fi
+            if command -v getconf >/dev/null 2>&1 && getconf GNU_LIBC_VERSION >/dev/null 2>&1; then
+                echo "gnu"
+                return 0
+            fi
+            echo "gnu"
+            ;;
+        *) die "invalid DCRUP_LIBC / --libc: $pref (use gnu|musl|auto)" ;;
+    esac
+}
+
+detect_triple() {
+    local os arch libc
+    os="$(uname -s)"
+    arch="$(uname -m)"
+    case "$os:$arch" in
+        Linux:x86_64)
+            libc="$(detect_linux_libc)"
+            if [[ "$libc" == "musl" ]]; then
+                echo "x86_64-unknown-linux-musl"
+            else
+                echo "x86_64-unknown-linux-gnu"
+            fi
+            ;;
+        Linux:aarch64|Linux:arm64)
+            libc="$(detect_linux_libc)"
+            if [[ "$libc" == "musl" ]]; then
+                echo "aarch64-unknown-linux-musl"
+            else
+                echo "aarch64-unknown-linux-gnu"
+            fi
+            ;;
+        Linux:i686|Linux:i386)
+            libc="$(detect_linux_libc)"
+            if [[ "$libc" == "musl" ]]; then
+                echo "i686-unknown-linux-musl"
+            else
+                echo "i686-unknown-linux-gnu"
+            fi
+            ;;
+        Linux:armv7l|Linux:armv7)
+            libc="$(detect_linux_libc)"
+            if [[ "$libc" == "musl" ]]; then
+                echo "armv7-unknown-linux-musleabihf"
+            else
+                echo "armv7-unknown-linux-gnueabihf"
+            fi
+            ;;
+        Linux:riscv64)
+            libc="$(detect_linux_libc)"
+            if [[ "$libc" == "musl" ]]; then
+                echo "riscv64gc-unknown-linux-musl"
+            else
+                echo "riscv64gc-unknown-linux-gnu"
+            fi
+            ;;
+        Darwin:x86_64)               echo "x86_64-apple-darwin" ;;
+        Darwin:arm64|Darwin:aarch64) echo "aarch64-apple-darwin" ;;
+        FreeBSD:x86_64|FreeBSD:amd64) echo "x86_64-unknown-freebsd" ;;
+        FreeBSD:aarch64|FreeBSD:arm64) echo "aarch64-unknown-freebsd" ;;
+        OpenBSD:x86_64|OpenBSD:amd64) echo "x86_64-unknown-openbsd" ;;
+        NetBSD:x86_64|NetBSD:amd64)  echo "x86_64-unknown-netbsd" ;;
+        MINGW*|MSYS*|CYGWIN*)
+            case "$arch" in
+                x86_64|amd64) echo "x86_64-pc-windows-gnu" ;;
+                aarch64|arm64) echo "aarch64-pc-windows-gnullvm" ;;
+                i686|i386) echo "i686-pc-windows-gnu" ;;
+                *) die "unsupported Windows arch under MSYS: $arch" ;;
+            esac
+            ;;
+        *) die "unsupported platform: $os/$arch" ;;
+    esac
+}
+
+normalize_version() {
+    local v="$1"
+    v="${v#v}"
+    printf '%s' "$v"
+}
+
+parse_spec() {
+    local raw="$1"
+    SPEC_RAW="$raw"
+    SPEC_CHANNEL=""
+    SPEC_VERSION=""
+    SPEC_FLOATING=0
+
+    case "$raw" in
+        "") die "missing version/channel spec" ;;
+        stable|dev|night)
+            SPEC_CHANNEL="$raw"
+            SPEC_VERSION=""
+            SPEC_FLOATING=1
+            ;;
+        *@*)
+            SPEC_VERSION="$(normalize_version "${raw%@*}")"
+            SPEC_CHANNEL="${raw#*@}"
+            case "$SPEC_CHANNEL" in
+                stable|dev) ;;
+                night) die "cannot pin a version on night (use: dcrup install night)" ;;
+                *) die "unknown channel in spec: $SPEC_CHANNEL (use stable|dev)" ;;
+            esac
+            [[ -n "$SPEC_VERSION" ]] || die "empty version in spec: $raw"
+            ;;
+        *)
+            SPEC_VERSION="$(normalize_version "$raw")"
+            SPEC_CHANNEL="stable"
+            [[ -n "$SPEC_VERSION" ]] || die "invalid spec: $raw"
+            ;;
+    esac
+}
+
+toolchain_id() {
+    if [[ "$SPEC_CHANNEL" == "night" ]]; then
+        local sha="${1:-unknown}"
+        echo "night-${sha}"
+    elif [[ "$SPEC_FLOATING" -eq 1 ]]; then
+        local ver="${1:-latest}"
+        echo "${SPEC_CHANNEL}-${ver}"
+    else
+        echo "${SPEC_VERSION}-${SPEC_CHANNEL}"
+    fi
+}
+
+ensure_dirs() {
+    mkdir -p "$DCRUP_TC" "$DCRUP_BIN" "$DCRUP_META"
+}
+
+active_file() { echo "$DCRUP_META/active"; }
+
+read_active() {
+    if [[ -f "$(active_file)" ]]; then
+        cat "$(active_file)"
+    fi
+}
+
+write_active() {
+    printf '%s\n' "$1" >"$(active_file)"
+}
+
+link_default() {
+    local id="$1"
+    local src="$DCRUP_TC/$id/dcr"
+    [[ -x "$src" ]] || die "toolchain not installed: $id"
+    ln -sfn "$src" "$DCRUP_BIN/dcr"
+    write_active "$id"
+    ok "default → $id ($DCRUP_BIN/dcr)"
+}
+
+fetch_json() {
+    need_cmd curl
+    curl -fsSL "$1"
+}
+
+json_tag() {
+    printf '%s' "$1" | sed -n 's/.*"tag_name"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' | head -n1
+}
+
+json_asset_url() {
+    local json="$1" asset="$2"
+    printf '%s' "$json" | sed -n "s#.*\"browser_download_url\"[[:space:]]*:[[:space:]]*\"\([^\"]*/${asset}\)\"#\1#p" | head -n1
+}
+
+latest_stable_json() {
+    fetch_json "$API_LATEST"
+}
+
+latest_dev_json() {
+    need_cmd curl
+    local json result
+    json="$(fetch_json "$API_ALL")"
+    if command -v jq >/dev/null 2>&1; then
+        result="$(printf '%s' "$json" | jq -e -c '[.[] | select(.prerelease == true)][0]')" || true
+    elif command -v python3 >/dev/null 2>&1; then
+        result="$(printf '%s' "$json" | python3 -c '
+import sys, json
+rels = json.load(sys.stdin)
+pre = [r for r in rels if r.get("prerelease")]
+print(json.dumps(pre[0]) if pre else "", end="")
+')"
+    else
+        die "dev channel needs jq or python3 to parse GitHub API"
+    fi
+    [[ -n "$result" && "$result" != "null" ]] || die "no prerelease (dev) found"
+    printf '%s' "$result"
+}
+
+release_json_for_spec() {
+    if [[ "$SPEC_FLOATING" -eq 1 ]]; then
+        case "$SPEC_CHANNEL" in
+            stable) latest_stable_json ;;
+            dev)    latest_dev_json ;;
+            night)  die "night has no GitHub release binary" ;;
+        esac
+    else
+        fetch_json "https://api.github.com/repos/dexoron/dcr/releases/tags/v${SPEC_VERSION}"
+    fi
+}
+
+install_prebuilt() {
+    local triple asset tag version url json id dest
+    need_cmd curl
+    triple="$(detect_triple)"
+    json="$(release_json_for_spec)"
+    tag="$(json_tag "$json")"
+    [[ -n "$tag" ]] || die "failed to parse release tag"
+    version="$(normalize_version "$tag")"
+    asset="dcr-${triple}-${version}"
+    case "$triple" in
+        *windows*) asset="${asset}.exe" ;;
+    esac
+    url="$(json_asset_url "$json" "$asset")"
+    [[ -n "$url" ]] || die "asset not found: $asset (tag $tag)"
+
+    id="$(toolchain_id "$version")"
+    dest="$DCRUP_TC/$id"
+    if [[ -x "$dest/dcr" && "${FORCE:-0}" != "1" ]]; then
+        ok "already installed: $id"
+        link_default "$id"
+        return 0
+    fi
+
+    log "downloading $asset …"
+    mkdir -p "$dest"
+    curl -fL "$url" -o "$dest/dcr"
+    chmod +x "$dest/dcr"
+    printf '%s\n' \
+        "channel=$SPEC_CHANNEL" \
+        "version=$version" \
+        "tag=$tag" \
+        "source=release" \
+        "triple=$triple" \
+        "libc=${DCRUP_LIBC:-gnu}" \
+        >"$dest/dcrup-meta"
+    ok "installed prebuilt $id ($triple)"
+    link_default "$id"
+}
+
+install_build() {
+    local tmp id dest sha version branch_or_tag
+    need_cmd git
+    need_cmd cargo
+
+    tmp="$(mktemp -d "${TMPDIR:-/tmp}/dcrup.XXXXXX")"
+    cleanup_tmp() { rm -rf "$tmp"; }
+    trap cleanup_tmp EXIT
+
+    if [[ "$SPEC_CHANNEL" == "night" ]]; then
+        log "cloning $REPO_URL (branch dev) for night …"
+        git clone --depth 1 --branch dev "$REPO_URL" "$tmp/src" 2>/dev/null \
+            || git clone --depth 1 "$REPO_URL" "$tmp/src"
+        sha="$(git -C "$tmp/src" rev-parse --short HEAD)"
+        version="night"
+        id="$(toolchain_id "$sha")"
+    elif [[ "$SPEC_FLOATING" -eq 1 ]]; then
+        local json tag
+        json="$(release_json_for_spec)"
+        tag="$(json_tag "$json")"
+        [[ -n "$tag" ]] || die "failed to resolve floating channel tag"
+        version="$(normalize_version "$tag")"
+        id="$(toolchain_id "$version")"
+        log "cloning $REPO_URL @ $tag …"
+        git clone --depth 1 --branch "$tag" "$REPO_URL" "$tmp/src" 2>/dev/null \
+            || {
+                git clone --depth 1 "$REPO_URL" "$tmp/src"
+                git -C "$tmp/src" fetch --depth 1 origin "refs/tags/${tag}:refs/tags/${tag}"
+                git -C "$tmp/src" checkout "$tag"
+            }
+        sha="$(git -C "$tmp/src" rev-parse --short HEAD)"
+    else
+        version="$SPEC_VERSION"
+        id="$(toolchain_id)"
+        local tag="v${SPEC_VERSION}"
+        log "cloning $REPO_URL @ $tag …"
+        git clone --depth 1 --branch "$tag" "$REPO_URL" "$tmp/src" 2>/dev/null \
+            || {
+                git clone --depth 1 "$REPO_URL" "$tmp/src"
+                git -C "$tmp/src" fetch --depth 1 origin "refs/tags/${tag}:refs/tags/${tag}"
+                git -C "$tmp/src" checkout "$tag"
+            }
+        sha="$(git -C "$tmp/src" rev-parse --short HEAD)"
+    fi
+
+    dest="$DCRUP_TC/$id"
+    if [[ -x "$dest/dcr" && "${FORCE:-0}" != "1" ]]; then
+        ok "already installed: $id"
+        link_default "$id"
+        return 0
+    fi
+
+    log "building release (features: $FEATURES) …"
+    (
+        cd "$tmp/src"
+        # shellcheck disable=SC2086
+        cargo build --release --features $FEATURES
+    )
+    mkdir -p "$dest"
+    cp "$tmp/src/target/release/dcr" "$dest/dcr"
+    chmod +x "$dest/dcr"
+    printf '%s\n' "channel=$SPEC_CHANNEL" "version=$version" "git=$sha" "source=build" "features=$FEATURES" >"$dest/dcrup-meta"
+    ok "installed build $id"
+    link_default "$id"
+    trap - EXIT
+    cleanup_tmp
+}
+
+cmd_install() {
+    local mode="release" FORCE=0
+    local spec=""
+    local libc_cli=""
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --build) mode="build"; shift ;;
+            --release) mode="release"; shift ;;
+            --force) FORCE=1; shift ;;
+            --libc)
+                [[ $# -ge 2 ]] || die "--libc needs gnu|musl|auto"
+                libc_cli="$2"
+                shift 2
+                ;;
+            --libc=*)
+                libc_cli="${1#--libc=}"
+                shift
+                ;;
+            -h|--help) usage; exit 0 ;;
+            -*) die "unknown flag: $1" ;;
+            *)
+                [[ -z "$spec" ]] || die "unexpected argument: $1"
+                spec="$1"
+                shift
+                ;;
+        esac
+    done
+    [[ -n "$spec" ]] || die "usage: dcrup install <spec> [--build|--release] [--force] [--libc gnu|musl|auto]"
+    parse_spec "$spec"
+    ensure_dirs
+
+    if [[ -n "$libc_cli" ]]; then
+        case "$libc_cli" in
+            gnu|glibc|musl|auto) DCRUP_LIBC="$libc_cli" ;;
+            *) die "invalid --libc: $libc_cli (use gnu|musl|auto)" ;;
+        esac
+    fi
+    export DCRUP_LIBC="${DCRUP_LIBC:-gnu}"
+
+    if [[ "$SPEC_CHANNEL" == "night" ]]; then
+        mode="build"
+    fi
+
+    export FORCE
+    log "install spec=$SPEC_RAW channel=$SPEC_CHANNEL version=${SPEC_VERSION:-∅} mode=$mode libc=$DCRUP_LIBC"
+    if [[ "$mode" == "build" ]]; then
+        install_build
+    else
+        install_prebuilt
+    fi
+    check_path
+}
+
+cmd_default() {
+    [[ $# -eq 1 ]] || die "usage: dcrup default <spec>"
+    parse_spec "$1"
+    ensure_dirs
+    local id
+    if [[ "$SPEC_CHANNEL" == "night" || "$SPEC_FLOATING" -eq 1 ]]; then
+        id="$(ls -1 "$DCRUP_TC" 2>/dev/null | grep -E "^${SPEC_CHANNEL}-" | sort | tail -n1 || true)"
+        [[ -n "$id" ]] || die "no installed toolchain for channel $SPEC_CHANNEL (run: dcrup install $SPEC_CHANNEL)"
+    else
+        id="$(toolchain_id)"
+        [[ -d "$DCRUP_TC/$id" ]] || die "not installed: $id (run: dcrup install $1)"
+    fi
+    link_default "$id"
+}
+
+cmd_update() {
+    ensure_dirs
+    local active
+    active="$(read_active)"
+    [[ -n "$active" ]] || die "no active toolchain (run: dcrup install stable)"
+    case "$active" in
+        night-*)
+            log "updating night (rebuild HEAD) …"
+            FORCE=1 cmd_install night --build --force
+            ;;
+        stable-*|dev-*)
+            local ch="${active%%-*}"
+            log "updating floating channel $ch …"
+            FORCE=1 cmd_install "$ch" --force
+            ;;
+        *-stable|*-dev)
+            ok "pinned toolchain $active — not floating; install a newer version explicitly"
+            ;;
+        *)
+            warn "unknown active id $active; try: dcrup install stable"
+            ;;
+    esac
+}
+
+cmd_list() {
+    ensure_dirs
+    local active
+    active="$(read_active)"
+    if [[ ! -d "$DCRUP_TC" ]] || [[ -z "$(ls -A "$DCRUP_TC" 2>/dev/null || true)" ]]; then
+        warn "no toolchains installed"
+        return 0
+    fi
+    local d base
+    for d in "$DCRUP_TC"/*; do
+        [[ -d "$d" ]] || continue
+        base="$(basename "$d")"
+        if [[ "$base" == "$active" ]]; then
+            printf ' * %s\n' "$base"
+        else
+            printf '   %s\n' "$base"
+        fi
+    done
+}
+
+cmd_show() {
+    ensure_dirs
+    local active
+    active="$(read_active)"
+    echo "DCRUP_HOME=$DCRUP_HOME"
+    echo "DCRUP_BIN=$DCRUP_BIN"
+    echo "active=${active:-none}"
+    if [[ -n "$active" && -f "$DCRUP_TC/$active/dcrup-meta" ]]; then
+        echo "--- meta ---"
+        cat "$DCRUP_TC/$active/dcrup-meta"
+    fi
+    if [[ -x "$DCRUP_BIN/dcr" ]]; then
+        echo "--- dcr --version ---"
+        "$DCRUP_BIN/dcr" --version 2>/dev/null || true
+    fi
+}
+
+cmd_which() {
+    if [[ -L "$DCRUP_BIN/dcr" || -e "$DCRUP_BIN/dcr" ]]; then
+        readlink -f "$DCRUP_BIN/dcr" 2>/dev/null || readlink "$DCRUP_BIN/dcr" 2>/dev/null || echo "$DCRUP_BIN/dcr"
+    else
+        die "dcr not linked (run: dcrup install stable)"
+    fi
+}
+
+cmd_uninstall() {
+    ensure_dirs
+    if [[ "${1:-}" == "--all" ]]; then
+        rm -rf "$DCRUP_TC"
+        rm -f "$DCRUP_BIN/dcr" "$(active_file)"
+        ok "removed all toolchains"
+        return 0
+    fi
+    [[ $# -eq 1 ]] || die "usage: dcrup uninstall <spec>|--all"
+    parse_spec "$1"
+    local id
+    if [[ "$SPEC_FLOATING" -eq 1 || "$SPEC_CHANNEL" == "night" ]]; then
+        id="$(ls -1 "$DCRUP_TC" 2>/dev/null | grep -E "^${SPEC_CHANNEL}-" | sort | tail -n1 || true)"
+    else
+        id="$(toolchain_id)"
+    fi
+    [[ -n "$id" && -d "$DCRUP_TC/$id" ]] || die "not installed: $1"
+    rm -rf "$DCRUP_TC/$id"
+    if [[ "$(read_active)" == "$id" ]]; then
+        rm -f "$DCRUP_BIN/dcr" "$(active_file)"
+        warn "removed active toolchain; run: dcrup install stable"
+    fi
+    ok "removed $id"
+}
+
+check_path() {
+    case ":$PATH:" in
+        *":$DCRUP_BIN:"*) ;;
+        *)
+            warn "$DCRUP_BIN is not in PATH"
+            echo "Add to ~/.bashrc / ~/.zshrc / ~/.profile:"
+            echo "  export PATH=\"$DCRUP_BIN:\$PATH\""
+            ;;
+    esac
+}
+
+cmd_self_install() {
+    local dest="$DCRUP_BIN"
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --to) dest="$2"; shift 2 ;;
+            *) die "usage: dcrup self-install [--to DIR]" ;;
+        esac
+    done
+    ensure_dirs
+    mkdir -p "$dest"
+    local self
+    self="$(readlink -f "$0" 2>/dev/null || realpath "$0" 2>/dev/null || echo "$0")"
+    cp "$self" "$dest/dcrup"
+    chmod +x "$dest/dcrup"
+    ok "dcrup installed to $dest/dcrup"
+    check_path
+    echo "Then: dcrup install stable"
+}
+
+main() {
+    local cmd="${1:-}"
+    shift || true
+    case "$cmd" in
+        ""|-h|--help|help) usage ;;
+        install) cmd_install "$@" ;;
+        default) cmd_default "$@" ;;
+        update) cmd_update "$@" ;;
+        list) cmd_list "$@" ;;
+        show) cmd_show "$@" ;;
+        which) cmd_which "$@" ;;
+        uninstall) cmd_uninstall "$@" ;;
+        self-install) cmd_self_install "$@" ;;
+        *) die "unknown command: $cmd (try: dcrup help)" ;;
+    esac
+}
+
+main "$@"
--- a/docs/README.mdx
+++ b/docs/README.mdx
@@ -8,8 +8,10 @@ sidebar_label: Introduction
 <summary>Quick reference</summary>

 ```bash
-# Installation
-curl -fsSL https://dcr.dexoron.su/install.sh | sh
+# Installation (dcrup)
+curl -fsSL https://sh.dcr-tool.ru | sh -s -- self-install
+export PATH="$HOME/.dcr/bin:$PATH"
+dcrup install stable

 # Create a project
 dcr new my-app
@@ -51,8 +53,9 @@ dcr gen vscode

 - **Incremental builds** — mtime + `.d` headers + SHA256 fingerprint
 - **Parallel compilation** — thread::scope, atomic task queue
- **4 backends** — gcc/clang, MSVC/clang-cl, GAS (ARM), NASM (x86)
- **7 project kinds** — bin, staticlib, sharedlib, efi, elf, none, custom
+- **7 backends** — gcc/clang (unix_cc), MSVC/clang-cl (msvc), GAS, NASM, MASM, FASM, LLVM IR
+- **8 project kinds** — bin, staticlib, sharedlib, efi, elf, none, custom, flat-bin
+- **Disk images** — optional `[archive]` packs FAT12/16/32 images after build
 - **Cross-compilation** — short names and full triples
 - **Profiles** — debug / release with field overrides
 - **Workspaces** — multi-package projects with topological sort
--- a/docs/changelog.mdx
+++ b/docs/changelog.mdx
@@ -4,6 +4,184 @@ sidebar_label: Changelog

 # Changelog

+## 0.8.5 (2026-08-08)
+
+- **`package.dcr-version`** — optional CLI version pin in `dcr.toml`.
+  `dcr new` / `dcr init` write the current version. On config load:
+  - missing / empty pin → warn "add dcr-version";
+  - dcr older than pin → warn "update dcr";
+  - dcr newer than pin → warn "check changelog, update pin";
+  - equal → silent.
+    Commands do not fail, warning only (once per path per process).
+
+## 0.8.4 (2026-08-04)
+
+**Added:**
+
+- **`.dcr/` directory** — shared machine-readable build facts for IDE integrations:
+  - `.dcr/compile_commands.json`
+  - `.dcr/build-info.json` (`schemaVersion`, `artifact_path`, `profile`, …)
+  - `.dcr/toolchain.json` (compiler/debugger paths, moc/uic/rcc)
+  - `.dcr/ide/` (placeholder for IDE lock files)
+- **`dcr gen project-info`** — `target`, `target_dir`, `artifact_path`, `artifact_kind`, `source_roots`, `include_globs`, `exclude_globs`; absolute/canonical paths.
+- **`dcr build --print-artifact-path`** — one absolute artifact path line on stdout after a successful build.
+- **`dcr gen … --quiet` / `-q`** — suppress human success logs for gen subcommands.
+- **`.clangd`** — created on first gen with `CompilationDatabase: .dcr` (`# managed by dcr gen`); custom `.clangd` is not overwritten.
+- **Helpers** `canonicalize_path`, `atomic_write`, `ensure_dcr_dir`; pure `resolve_artifact_path` via `platform::*`.
+- **`dcr new` / `dcr init`** — add `.dcr/` to `.gitignore`.
+
+**Changed (breaking):**
+
+- **`compile_commands.json` moved** from project root to **`.dcr/compile_commands.json`**.  
+  clangd discovers it via `.clangd` / `--compile-commands-dir=.dcr`.  
+  CLion and VSCode generators updated accordingly.
+- **Atomic write** for compile_commands (tmp + rename).
+- **`gen vscode` / `gen clion` launch/run** — use the same artifact path resolver as `project-info` / `build-info.json`.
+
+**Fixed:**
+
+- Launch configs no longer hardcode `target/<profile>/<name>` without the Linux triple segment.
+- Symlink/mount roots: best-effort canonicalize for root and compile database paths.
+
+## 0.8.3 (2026-08-03)
+
+### Added
+
+- **`dcr run -- <args>...`** — cargo-style argument forwarding after a bare `--`  
+  (`dcr run --release -- --test_help`). Applies to direct binary runs and `[run].cmd`.
+- **Tests** — host target section `ldflags` without CLI `--target`; run-arg forwarding; `split_double_dash` unit tests.
+
+### Changed
+
+- **Native builds resolve the host triple** — without `--target` / package `build.target`, host sections such as  
+  `[build.x86_64-unknown-linux-gnu]` apply again (`cflags` / `ldflags` / toolchain).  
+  Previously the target was empty and those sections were ignored while artifacts already used the host triple path.
+- **Empty target** — no more `Unknown target ''` warning.
+- **`dcr run --help` / man `dcr-run`** — document `--` forwarding.
+
+### Fixed
+
+- **Native artifact paths on Windows and macOS** — without an explicit `--target` / `build.target`, artifacts use `target/<profile>`, so `dcr run` and flat-bin find the build output.
+- Target-specific `ldflags` missing on native host builds (e.g. micro-lang + `libsct-elf`).
+- Spurious empty-target warning.
+
+## 0.8.2 (2026-07-22)
+
+### Added
+
+- **Compile progress `[N/M]`** — live TTY status line (`compile  pkg v0.1.0  [12/41]`) so long mono-package builds do not look hung.
+- **DCR status style** — fixed-width verbs: `project`, `compile`, `dep`, `ready`, `pack`, `done`, `run`.
+- **Cargo feature `archive`** — optional FAT packing via `fatfs` (`cargo build --features archive`). Release CI builds with the feature; without it `[archive]` fails with a clear message.
+- **Tests** — `flat_bin_nasm_build`, package `build.target` without CLI `--target`, stricter workspace `clean --all`.
+- **CI expansion** — unit + integration on Linux/macOS/Windows, archive feature job, rust-cache, clippy default + all-features (see `.github/workflows/ci.yml`).
+
+### Changed
+
+- **No forced host triple from CLI** — without `--target`, package/member `build.target` is honored (bare-metal / ISO `post_steps` paths).
+- **Relative include/lib flags** (`-I`, `-i`, `-isystem`, `-idirafter`, `-L`, `-T`) absolutized against the package root under workspace builds.
+- **`dcr clean --all`** — no spam for members without a local `target/` (shared root `target/`).
+- **`error` / `warn`** — red / yellow on stderr; CLI fully English (`Hint:`).
+- **Help / man** — list `add`, `lint`, `setup`; unknown command exits with code 1.
+- **Tool NotFound** — `linker not found: ld.lld …` / `{tool} not found …` instead of raw `os error 2`.
+
+## 0.8.1 (2026-07-20)
+
+### Added
+
+- **`build.kind = "flat-bin"`** — raw binary (default `.bin`) for OS-dev payloads:
+  - **NASM** — `-f bin` → `<stem>.bin`
+  - **FASM** — direct output (`format binary` in source)
+  - **GAS / MASM / LLC** — object → `objcopy -O binary` → `<stem>.bin`
+  - **C/C++** — objects → freestanding link → `objcopy -O binary` → `<name>.bin`
+  - Requires `llvm-objcopy` / `objcopy` / `gobjcopy` except for NASM/FASM direct emit
+- **`[archive]` section** — FAT12/16/32 disk images after build (`output`, `format`, `size`, `offset`, `label`, `bootsector`, `layout`). From 0.8.2 requires feature `archive`.
+- **Single-file `build.roots`** — a root may be a single source or header file, not only a directory.
+
+### Changed
+
+- **`--force`** also re-runs `build.steps` and `build.post_steps`.
+- **`dcr run` on workspace-only root** — if `[run].cmd` is set, run that after build; otherwise delegate to a workspace member.
+
+## 0.8.0 (2026-07-18)
+
+### Added
+
+- **Dedicated Build Engine (`src/core/build/engine.rs`)** — decoupled the build orchestration logic completely from the CLI front-end wrapper in `src/cli/build.rs` to a reusable, decoupled core build engine.
+- **Polymorphic Language Model (`Language` trait)** — introduced the abstract `Language` trait (`src/core/build/language/mod.rs`). File scanning, compiler resolution, and flags handling are now encapsulated in dedicated language modules for C, C++ (including Qt code generation), LLVM IR, and ASM (GAS, NASM, FASM, MASM).
+- **Polymorphic Compilation Dispatch (`Builder` trait)** — introduced the `Builder` trait to generalize builder invocations (`src/core/build/builder/mod.rs`). Consolidated GCC/Clang logic into `builder/cc_common.rs` and Microsoft Visual C++ logic into `builder/msvc/`.
+- **Per-Language Configuration overrides (`[build.<lang>]`)** — introduced support for configuring language-specific compiler, standard, and flags (e.g. `[build.c]`, `[build.cxx]`, `[build.asm]`) independently in `dcr.toml`.
+- **Automatic Workspace Dependency Injection** — during workspace builds, include/lib paths of dependent workspace members (including their source headers, local `include/` folders, and build target `target/include` / `target/lib` folders) are automatically resolved and injected.
+- **`BuildReporter` Event System** — decoupled build orchestration output into a structured event-driven reporter model (`src/core/build/report.rs`), making DCR suitable for library embedding and IDE integrations without stderr capturing.
+- **Build Cancellation Support** — introduced thread-safe cancellation tokens (`Arc<AtomicBool>`) allowing clients to safely abort compile runs mid-execution.
+- **TOML Formatting & Custom Keys Preservation** — migrated the config editor to `toml_edit`, preserving all unknown/user-defined TOML keys, structures, and comments during file write operations (e.g., in `dcr add`).
+- **Path Dependencies Target Include Resolution** — local path dependencies configured via tables now correctly expose headers built and packaged into their `target/include` folder to consumer packages.
+- **Modular Integration Test Suite** — refactored the monolith `tests/cli_basic.rs` file into clean, specialized integration tests: `cli_build.rs`, `cli_deps.rs`, `cli_lint.rs`, `cli_new.rs`, `cli_qt.rs`, `cli_test.rs`, `cli_workspace.rs`.
+
+### Changed
+
+- **Consolidated Linking and Archiving** — artifact generation (linking executables/shared libraries and archiving static libraries) consolidated into a single `src/core/build/builder/artifact.rs` module.
+- **Workspace-Aware member execution** — `dcr run` executed at the workspace root of a `workspace_only` project now triggers the member build inside the workspace context using the `--workspace` parameter, preventing standalone build issues.
+- **Elimination of Global State** — removed global variables and states from the build core, encapsulating build logic inside isolated `BuildContext` structs for thread safety.
+- **Build Cache Separation** — relocated mtime tracking, incremental caching, and header-dependency checking logic to `src/core/build/cache.rs`.
+- **Modularized Pre-build Steps** — decoupled generator scripts and pre-build commands parsing into `src/core/build/steps.rs`.
+
+## 0.7.4 (2026-06-17)
+
+### Added
+
+- **Native Qt support** — automatic meta-object handling (MOC, UIC, RCC) added when `build.qt = true` is set in `dcr.toml`.
+- **`dcr lint` command** — C/C++ static analysis via `clang-tidy`. Supports `--fix` for automatic fixes. Respects `build.roots` and `build.src_disable` from config.
+- **Three new assembler backends**:
+  - **MASM** (`compiler = "ml"` / `"ml64"`) — Microsoft Macro Assembler.
+  - **FASM** (`compiler = "fasm"`) — Flat Assembler.
+  - **LLVM IR** (`compiler = "llc"`) — compiles `.ll` files via `llc -filetype=obj`.
+- **Shared ASM pipeline** — linking and archiving logic consolidated into `core/builder/asm.rs`. Adding a new assembler backend now takes ~30 lines.
+- **Filesystem utilities** — `to_hex()` and `home_dir()` extracted to `utils/fs.rs`.
+- **Build utilities** — `normalize_target()`, `normalize_kind()`, `normalize_platform()`, `default_profile_flags()` extracted to `utils/build.rs`.
+- **Backend helpers** — `asm_lang_flag()`, `source_extensions()`, `elapsed_secs()` added to `core/builder/common.rs`.
+- **Full Bare-Metal / Freestanding Automation** — introduced the `build.freestanding = true` configuration option. When enabled (or when a bare-metal target is detected), DCR automatically injects `-ffreestanding` during compilation and both `-nostdlib` and `-static` during linking.
+- **Artifact Optimization (LTO & Strip)** — added `build.lto` (auto-injects `-flto` for compiler and linker) and `build.strip` (automatically strips debug symbols via linker `-s` flag) options to `dcr.toml`.
+- **Compilation Thread Control** — added the `build.codegen-units` option to strictly limit the maximum number of parallel jobs utilized by the custom `parallel_build` worker pool.
+- **Panic Behavior Management** — added `build.panic = "abort"` support. For C++ targets, it automatically strips exception handling and unwind tables via `-fno-exceptions`, `-fno-unwind-tables`, and `-fno-asynchronous-unwind-tables`.
+
+### Changed
+
+- **Intelligent Default Flags Generation** — automated injection of fallback optimization (`-O3`/`-O0`), debug (`-g`), and warning (`-Wall -Wextra`) flags is now suppressed for bare-metal and freestanding builds if `build.cflags` are overridden.
+- **Centralized Bare-Metal Detection** — relocated the `is_bare_metal_target` helper to common build utilities (`src/utils/build.rs`) for unified access across the building core.
+- **Architectural Refactoring**:
+  - Renamed `src/config.rs` to `src/templates.rs`.
+  - Started consolidation of configuration and build orchestration logic.
+
+## 0.7.3 (2026-06-13)
+
+### Added
+
+- **`--vcs` option for `new` and `init` commands** — introduced explicit version control system selection via `--vcs <git|none>`.
+- **Git metadata integration in `--version`** — the CLI now appends the current short commit hash and a `-dirty` suffix if there are uncommitted changes in the DCR repository.
+- **Automatic `.gitignore` generation** — Git repository initialization now automatically writes a `.gitignore` file excluding the `/target` directory.
+- **Nested repository prevention** — automatic Git initialization is now skipped if `dcr new` or `dcr init` is executed inside an already existing Git repository.
+- **VCS verification tests** — added `new_vcs_options_work` and `init_vcs_options_work` integration tests to ensure reliable repository behavior.
+
+### Changed
+
+- **Complete removal of `git2` dependency** — all Git actions (dependency fetching, VCS setup, status checks) are now delegated to the system `git` executable via `Command`. This simplifies compilation and drops the need for `vendored` and `openssl` features.
+- **Migrated from `reqwest` to `ureq`** — replaced the heavy `reqwest` crate in `flag_update.rs` with the lightweight synchronous `ureq 2.10` client, reducing overhead and the final binary size.
+
+## 0.7.2 (2026-06-07)
+
+### Added
+
+- `default_target_triple()` now respects `target_env` — Linux (gnu/musl) and Windows (msvc/gnu) use the correct environment instead of hardcoded values.
+
+### Fixed
+
+- **macOS Apple Silicon builds failed with `_main` undefined** — `--target=` is now passed to ldflags, not just cflags. `default_target_triple()` uses `std::env::consts::ARCH` on macOS instead of hardcoded `x86_64`.
+- **GitHub Stars and GPL-3.0 badges not rendering in README** — badge block converted to pure HTML.
+
+### Changed
+
+- Default target resolution extracted into shared `default_target_triple()` — removed duplication across build, run, clean.
+
 ## 0.7.1 (2026-06-02)

 ### Added
--- a/docs/commands/build-commands.mdx
+++ b/docs/commands/build-commands.mdx
@@ -13,7 +13,7 @@ dcr build                         # debug profile
 dcr build --release               # release build
 dcr build --debug                 # explicit debug
 dcr build --target aarch64-unknown-linux-gnu
-dcr build --force                 # full rebuild
+dcr build --force                 # full rebuild (also re-runs build.steps / post_steps)
 dcr build --clean                 # clean + build
 dcr build --verbose               # show compilation commands
 dcr build --workspace pkg-a       # build specific workspace package
@@ -21,6 +21,8 @@ dcr build --workspace pkg-a       # build specific workspace package

 Artifacts: `target/<triple>/<profile>/<binary-name>` (Linux with explicit target).

+With `[archive]` in `dcr.toml`, a FAT disk image is packed after a successful build.
+
 ## `dcr run`

 Builds (if sources are newer than artifacts) and runs the binary.
@@ -28,8 +30,11 @@ Builds (if sources are newer than artifacts) and runs the binary.
 ```bash
 dcr run
 dcr run --release
+dcr run --force                   # force rebuild then run
 ```

+On a **workspace-only** root: if `[run].cmd` is set, that command is used after build; otherwise DCR delegates to a workspace member.
+
 ## `dcr clean`

 Removes `target/` directory (or `target/<target>/<profile>`).
--- a/docs/contributing.mdx
+++ b/docs/contributing.mdx
@@ -42,9 +42,10 @@ cargo test --all-targets

 ## CI

-CI runs:
+CI runs (see `.github/workflows/ci.yml`):
 - `cargo fmt --check`
- `cargo clippy --all-targets -- -D warnings`
- `cargo test --all-targets`
- Build on Linux, macOS, Windows
- Integration tests
+- `cargo clippy` (default + `--all-features`)
+- `cargo check --all-targets --all-features`
+- Unit + integration tests on Linux, macOS, Windows
+- Extra Linux job with `--features archive` (FAT images)
+- Tools on runners: clang, nasm, clang-format/tidy (Linux)
--- a/docs/faq.mdx
+++ b/docs/faq.mdx
@@ -39,27 +39,6 @@ which clang

 Or specify explicitly via `[toolchain]` in `dcr.toml`.

-## openssl-sys build failed
-
-When building DCR from source:
-
-```
-error: failed to run custom build command for openssl-sys
-```
-
-**Solution:** Install OpenSSL development headers:
-
-```bash
-# Ubuntu/Debian
-sudo apt install libssl-dev
-
-# Fedora
-sudo dnf install openssl-devel
-
-# macOS
-brew install openssl
-```
-
 ## Ctrl+C during build

 DCR handles SIGINT: interrupts the current compilation and exits with non-zero code.
@@ -76,6 +55,12 @@ See [Cross-Compile Recipe](/docs/recipes/cross-to-windows).

 See [Workspace Recipe](/docs/recipes/multi-package-workspace).

+## Bootloader / pure NASM OS image
+
+Use `kind = "flat-bin"` (NASM `-f bin`) and optional `[archive]` for a FAT disk image.
+
+See [OS-dev recipe](/docs/recipes/os-flat-bin-archive).
+
 ## Lock file

 `dcr.lock` is created during builds (`dcr build`) when registry dependencies are present. To force an update — delete `dcr.lock` and run `dcr build`.
--- a/docs/getting-started/first-steps.mdx
+++ b/docs/getting-started/first-steps.mdx
@@ -68,3 +68,11 @@ dcr test             # run tests
 ```bash
 dcr fmt              # clang-format with .clang-format
 ```
+
+## Linting
+
+```bash
+dcr lint             # clang-tidy checks
+dcr lint --fix       # apply fixes automatically
+```
+
--- a/docs/getting-started/installation.mdx
+++ b/docs/getting-started/installation.mdx
@@ -4,25 +4,64 @@ sidebar_label: Installation

 # Installation

-## Linux (Dexoron Packages)
+## dcrup (recommended)

-Configure your package manager at https://pkg.dexoron.su and install:
+Install and switch DCR versions (stable / dev / night, pin `0.8.2`, optional build from source).
+
+### Linux / macOS / BSD / Windows (bash)

-**Arch Linux**
 ```sh
-sudo pacman -Sy dcr
+curl -fsSL https://sh.dcr-tool.ru | sh -s -- self-install
+export PATH="$HOME/.dcr/bin:$PATH"
+dcrup install stable
 ```

-**Debian/Ubuntu**
+Non-interactive install of DCR in one shot:
+
 ```sh
-sudo apt update && sudo apt install dcr
+curl -fsSL https://sh.dcr-tool.ru | sh -s -- install stable
+export PATH="$HOME/.dcr/bin:$PATH"
 ```

-**Fedora/RHEL**
-```sh
-sudo dnf install dcr
+### Windows (PowerShell)
+
+```powershell
+irm https://ps1.dcr-tool.ru | iex
+# or download then run:
+# irm https://ps1.dcr-tool.ru -OutFile dcrup.ps1
+# powershell -File .\dcrup.ps1 self-install
+# $env:Path += ";$env:USERPROFILE\.dcr\bin"
+dcrup install stable
 ```

+Optional cmd bootstrap (if you prefer `curl` of the cmd shim):
+
+```bat
+curl -fsSL -o dcrup.cmd https://cmd.dcr-tool.ru
+```
+
+After `self-install`, the command is **`dcrup`** (no `.sh` / `.ps1`): shims live in `~/.dcr/bin` (Unix) or `%USERPROFILE%\.dcr\bin` (Windows `dcrup.cmd`).
+
+### Common dcrup commands
+
+```sh
+dcrup install stable              # latest stable prebuilt
+dcrup install 0.8.2               # pin → 0.8.2@stable
+dcrup install 0.8.2@dev
+dcrup install stable --libc musl  # Linux: musl asset (default: gnu)
+dcrup install stable --build      # cargo build --features archive
+dcrup install night               # always build from branch dev HEAD
+dcrup default 0.8.2
+dcrup update
+dcrup list
+dcrup show
+dcrup which
+```
+
+Layout: `~/.dcr/toolchains/<id>/dcr` and `~/.dcr/bin/dcr` → active version.
+
+---
+
 ## Arch Linux (AUR)

 ```sh
@@ -42,11 +81,12 @@ brew install dcr
 sudo snap install dcrup
 ```

+> If classic Snap Store publishing is unavailable, install the `.snap` from [GitHub Releases](https://github.com/dexoron/dcr/releases/latest) with `--dangerous`.
+
 ## Nix (flake)

 ```sh
 nix run github:dexoron/dcr
-# or install to profile:
 nix profile install github:dexoron/dcr
 ```

@@ -56,48 +96,37 @@ nix profile install github:dexoron/dcr
 cargo install dcr
 ```

-## Linux / macOS (script)
+Note: crates.io builds may omit optional features. For FAT disk images (`[archive]`), prefer release binaries or:

 ```sh
-curl -fsSL https://dcr.dexoron.su/install.sh | sh
-```
-
-## BSD (script)
-
-```sh
-curl -fsSL https://dcr.dexoron.su/install_bsd.sh | sh
-```
-
-## Windows (PowerShell)
-
-```powershell
-irm https://dcr.dexoron.su/install.ps1 | iex
+cargo install dcr --features archive
 ```

 ## From source

 ```sh
 git clone https://github.com/dexoron/dcr.git
-cd dcr && cargo build --release
+cd dcr
+cargo build --release --features archive
 ln -sf "$PWD/target/release/dcr" ~/.local/bin/dcr
+# or manage versions with dcrup install night / --build
 ```

 ## Post-install

-Verify the installation:
-
 ```bash
 dcr --version
+dcrup show    # if installed via dcrup
 ```

-Man pages are available after installation:
+Man pages (package installs / release assets):

 ```bash
 man dcr
 man dcr-build
 ```

-To use the registry, create `~/.dcr/config.toml`:
+Registry (optional) — `~/.dcr/config.toml`:

 ```toml
 [registry.default]
--- a/docs/recipes/os-flat-bin-archive.mdx
+++ b/docs/recipes/os-flat-bin-archive.mdx
@@ -0,0 +1,89 @@
+---
+sidebar_label: OS-dev (flat-bin + archive)
+---
+
+# Pure ASM / boot image (flat-bin + archive)
+
+Minimal OS-dev style pipeline: assemble raw binaries with NASM, then pack a FAT floppy/image with an optional boot sector.
+
+## Project layout
+
+```
+myos/
+  dcr.toml
+  src/
+    boot.asm      # boot sector (512 bytes)
+    kernel.asm    # payload
+```
+
+For multiple flat artifacts, use a **workspace** (one member per binary) or separate packages; a single `flat-bin` package produces one binary per source stem.
+
+## Boot package (`flat-bin`)
+
+```toml
+[package]
+name = "boot"
+version = "0.1.0"
+
+[build]
+language = "asm"
+compiler = "nasm"
+kind = "flat-bin"
+extension = "bin"
+roots = ["src/boot.asm"]
+```
+
+```bash
+dcr build
+# → target/<…>/debug/boot.bin  (NASM -f bin, no link)
+```
+
+## Disk image after build
+
+```toml
+[archive]
+output = "target/{profile}/disk.img"
+format = "fat12"
+size = "1440K"
+label = "MYOS"
+bootsector = "target/{profile}/boot.bin"
+
+[[archive.layout]]
+from = "target/{profile}/kernel.bin"
+to = "KERNEL.BIN"
+```
+
+- `format`: `fat12`, `fat16`, or `fat32`
+- `size`: bytes or `K`/`KB`/`M`/`MB`/`G`/`GB` (default ~1.44 MiB)
+- `bootsector`: written only when `offset` is omitted or `0`
+- `from` may be a glob; `{profile}` is substituted in paths
+
+## C kernel → flat binary
+
+```toml
+[build]
+language = "c"
+compiler = "clang"
+kind = "flat-bin"
+freestanding = true
+filename = "kernel"
+extension = "bin"
+ldflags = ["-T", "linker.ld"]
+```
+
+Pipeline: objects → temporary linked ELF → `objcopy -O binary` → `kernel.bin`. Requires `objcopy` / `llvm-objcopy` in PATH.
+
+## Other assemblers
+
+| Tool | Notes |
+|------|--------|
+| **FASM** | Write `format binary` in the source; DCR writes `<stem>.bin` directly |
+| **GAS** | Assemble `.s` → obj → `objcopy -O binary` |
+| **LLC** | `language = "llvm_ir"` → obj → objcopy |
+| **MASM** | COFF obj → objcopy (needs binutils/LLVM objcopy) |
+
+## Notes
+
+- Single-file `roots` are supported: `roots = ["src/boot.asm"]`.
+- `--force` re-runs `build.steps` / `build.post_steps` as well as recompilation.
+- Prefer `kind = "elf"` if you need a relocatable ELF kernel without stripping to raw binary.
--- a/docs/reference/build-system.mdx
+++ b/docs/reference/build-system.mdx
@@ -56,7 +56,7 @@ moc = "moc {in} -o {out}"
 ### GAS / NASM / MASM / FASM / LLVM-IR

 - GAS: `-I`, `-c -o`, `--defsym`
- NASM: `-I`, `-o`, `-D`, `-f` (format: win64/elf64/macho64/macho32/elf32)
+- NASM: `-I`, `-o`, `-D`, `-f` (format: win64/elf64/macho64/macho32/elf32; **`bin` when `kind = "flat-bin"`**)
 - MASM: `/nologo /c /Fo<obj> <source>`
 - FASM: `<source> <output>` (output path is the object file)
 - LLVM IR: `-filetype=obj <source> -o <output>`
@@ -87,6 +87,11 @@ Three levels of incrementality:
 | `elf` | ELF without stdlib | `target/<triple>/<profile>/<name>` |
 | `none` | Compile only, no link | — |
 | `custom` | Full filename+extension control | `target/<triple>/<profile>/<filename>.<extension>` |
+| `flat-bin` | Raw binary | ASM: `<stem>.bin` (NASM `-f bin` / FASM / GAS·MASM·LLC via objcopy); C/C++: `<name>.bin` (link + objcopy) |
+
+## Disk images (`[archive]`)
+
+After a successful build, if `[archive]` is present in `dcr.toml`, DCR formats a FAT volume and copies files from `layout` into the image. See [dcr.toml → archive](/docs/reference/dcr-toml#archive).

 ## Build Steps

--- a/docs/reference/cross-compilation.mdx
+++ b/docs/reference/cross-compilation.mdx
@@ -57,14 +57,8 @@ dcr build --target aarch64-none-elf

 ## Target Directory

-On Linux with explicit target:
+By default, the compilation output directories are structured as follows:

-```
-target/<triple>/<profile>/
-```
-
-On macOS/Windows or without target:
-
-```
-target/<profile>/
-```
+- **Linux and BSD**: Always output to `target/<triple>/<profile>/` (using host triple if no target is specified).
+- **macOS and Windows (without target)**: Output to `target/<profile>/`.
+- **macOS and Windows (with explicit target)**: Output to `target/<triple>/<profile>/`.
--- a/docs/reference/dcr-toml.mdx
+++ b/docs/reference/dcr-toml.mdx
@@ -33,6 +33,9 @@ Main project configuration file. Located at the project root.

 [run]
 # run settings
+
+[archive]
+# optional: pack FAT disk image after build
 ```

 ## [package]
@@ -40,7 +43,8 @@ Main project configuration file. Located at the project root.
 | Field | Required | Description |
 |-------|----------|-------------|
 | `name` | yes | Project name |
-| `version` | yes | Semantic version |
+| `version` | yes | Semantic version of the **project** |
+| `dcr-version` | no | Semver of the **dcr tool** this project targets. Written by `dcr new` / `dcr init` to the current tool version. |
 | `type` | no | `app`, `lib`, `none` (defaults to `"none"`) |
 | `license` | no | SPDX license identifier |
 | `author` | no | Author |
@@ -49,11 +53,26 @@ Main project configuration file. Located at the project root.
 [package]
 name = "my-app"
 version = "0.1.0"
+dcr-version = "0.8.4"
 type = "app"
 license = "MIT"
 author = "John Doe"
 ```

+### `package.dcr-version`
+
+Optional pin of the DCR CLI the project was written for. On every `dcr.toml` load:
+
+| Situation | Behaviour |
+|-----------|-----------|
+| Field missing / empty | Warning: add `dcr-version` (set by `dcr new` / `dcr init`) |
+| Running dcr **older** than pin | Warning: upgrade dcr (`dcr --update`) |
+| Running dcr **newer** than pin | Warning: review changelog, bump the pin when ready |
+| Equal | Silent |
+| Invalid semver | Warning once, field ignored |
+
+Never fails the command — warnings only. Pre-release suffixes (`1.0.0-dev`) are ignored for comparison (`1.0.0-dev` ≡ `1.0.0`).
+
 ## [build]

 ...
@@ -62,18 +81,18 @@ author = "John Doe"

 | Field | Default | Description |
 |-------|---------|-------------|
-| `language` | `"c"` | `"c"`, `"c++"`, `"cpp"`, `"cxx"`, `"asm"` (optional, defaults to `"c"`) |
+| `language` | `"c"` | `"c"`, `"c++"`, `"cpp"`, `"cxx"`, `"asm"`, `"llvm_ir"`, `"llvm-ir"`, `"ll"` (optional, defaults to `"c"`) |
 | `standard` | `"c11"` | C standard (`c11`, `c17`, `c23`) |
 | `cxx_standard` | — | C++ standard (`c++17`, `c++20`, `c++23`) |
 | `compiler` | `"clang"` | Preferred compiler (optional, defaults to `"clang"`) |
-| `kind` | `"bin"` | `bin`, `staticlib`, `sharedlib`, `efi`, `elf`, `none`, `custom` |
+| `kind` | `"bin"` | `bin`, `staticlib`, `sharedlib`, `efi`, `elf`, `none`, `custom`, `flat-bin` |
 | `target` | host | Target triple for cross-compilation |
 | `platform` | `"native"` | `native`, `efi` |
 | `cflags` | `[]` | Additional C/C++/ASM flags |
 | `ldflags` | `[]` | Additional linker flags |
 | `filename` | `""` | Custom output file name |
-| `extension` | `""` | Custom file extension |
-| `roots` | `["src"]` | Source root directories |
+| `extension` | `""` | Custom file extension (for `flat-bin`, default is `bin`) |
+| `roots` | `["src"]` | Source roots: directories and/or individual source/header files |
 | `exclude` | `[]` | Exclude patterns |
 | `include` | `[]` | Additional include directories |
 | `src_disable` | `false` | Disable auto source discovery |
@@ -96,7 +115,7 @@ Settings from raw config (not in typed struct):
 - `ldscript` — linker script path
 - `build.steps` / `build.post_steps` — codegen steps

-## Per-language overrides: `[build.c]`, `[build.cxx]`, `[build.asm]`
+## Per-language overrides: `[build.c]`, `[build.cxx]`, `[build.asm]`, `[build.llvm_ir]`

 Each language can have its own table that overrides the flat `[build]` settings:

@@ -116,6 +135,9 @@ compiler = "g++"
 [build.asm]
 compiler = "nasm"
 flags = ["-felf64"]
+
+[build.llvm_ir]
+compiler = "llc"
 ```

 The flat `[build]` acts as fallback; per-language tables take precedence for their language.
@@ -172,3 +194,84 @@ Default `cmd` = `./target/{profile}/{name}` (macOS/Windows) or `./target/<triple
 ## [workspace]

 See [workspaces](/docs/reference/workspaces).
+
+## [archive]
+
+Optional post-build step: format a FAT volume and copy built artifacts into a disk image. Runs after a successful package build (and after workspace member builds that define `[archive]`).
+
+Requires DCR built with the `archive` Cargo feature (`cargo build --features archive`). Release binaries include this feature.
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `output` | yes | Image path relative to project root (`{profile}` allowed) |
+| `format` | yes | `fat12`, `fat16`, or `fat32` |
+| `size` | no | Image size: bytes or `K`/`KB`/`M`/`MB`/`G`/`GB` (default `1474560` ≈ 1.44 MiB) |
+| `offset` | no | Byte offset of the FAT volume inside the image (default `0`) |
+| `label` | no | Volume label (max 11 chars, default `VOLUME`) |
+| `bootsector` | no | Path to a 512-byte boot sector written at offset 0 when `offset` is 0 (`{profile}` allowed) |
+| `layout` | no | List of `{ from, to }` entries (files or globs → path inside the volume) |
+
+```toml
+[archive]
+output = "target/{profile}/disk.img"
+format = "fat12"
+size = "1440K"
+label = "MYOS"
+bootsector = "target/{profile}/boot.bin"
+
+[[archive.layout]]
+from = "target/{profile}/kernel.bin"
+to = "KERNEL.BIN"
+
+[[archive.layout]]
+from = "assets/*"
+to = "/"
+```
+
+Typical pairing with `kind = "flat-bin"` (NASM `-f bin`) for bootloaders and pure-ASM OS images.
+
+## `flat-bin` (kind)
+
+Produces a raw binary (default extension `bin`) for boot sectors, kernels, and freestanding payloads.
+
+### Assemblers
+
+| Tool | Language / compiler | How flat-bin is produced |
+|------|---------------------|--------------------------|
+| NASM | `language = "asm"`, `compiler = "nasm"` | `-f bin` → `<stem>.bin` |
+| FASM | `compiler = "fasm"` | direct write (use `format binary` in source) |
+| GAS | `compiler = "as"` / `"gas"` | assemble → `objcopy -O binary` |
+| MASM | `compiler = "ml"` / `"ml64"` | assemble → `objcopy -O binary` |
+| LLC | `language = "llvm_ir"`, `compiler = "llc"` | `-filetype=obj` → `objcopy -O binary` |
+
+```toml
+[build]
+language = "asm"
+compiler = "nasm"
+kind = "flat-bin"
+extension = "bin"
+roots = ["src/boot.asm"]
+```
+
+### C / C++
+
+Compile all sources, link with `-nostdlib -static` (plus your `ldflags` / `ldscript`), then convert the intermediate ELF/PE with `objcopy -O binary` to `<filename|name>.bin`.
+
+```toml
+[build]
+language = "c"
+compiler = "clang"
+kind = "flat-bin"
+freestanding = true
+filename = "kernel"
+extension = "bin"
+ldscript = "linker.ld"
+ldflags = ["-T", "linker.ld"]
+```
+
+Notes:
+
+- Multi-file **ASM** packages emit one `<stem>.bin` per source; **C/C++** emit a single project binary.
+- `objcopy` tools tried in order: `llvm-objcopy`, `objcopy`, `gobjcopy`.
+- Incompatible with `build.qt = true`.
+- `dcr run` rejects `flat-bin` (not a host executable).
--- a/docs/reference/dependencies.mdx
+++ b/docs/reference/dependencies.mdx
@@ -67,6 +67,8 @@ mylib = { path = "/abs/path/to/lib" }
 mylib = { path = "../relative/path" }
 ```

+*Note: Header resolution automatically checks the packaged `target/include` directory of path dependencies, ensuring consumer packages can find headers from compiled static or dynamic libraries.*
+
 ## dcr.lock

 Dependency lock file. Contains package names and sources.
--- a/docs/reference/platform-support.mdx
+++ b/docs/reference/platform-support.mdx
@@ -11,17 +11,18 @@ DCR normalizes target triples. Short platform names are expanded to full triples
 ### Linux

 ```
-target/<arch>-unknown-linux-gnu/<profile>/
+target/<arch>-unknown-linux-<env>/<profile>/
 ```

-Architectures: `x86_64`, `aarch64` (host-detected).
+Architectures: `x86_64`, `aarch64`, `i686`, `armv7`, `riscv64` (host-detected).
+Environments: `gnu` (default), `musl`.

 Artifact type: ELF. Extensions: `.so` (sharedlib), `.a` (staticlib).

 ### macOS

 ```
-target/<profile>/
+target/<profile>/ (default) or target/<triple>/<profile>/ (with target)
 ```

 Architectures: `x86_64`, `aarch64` (host-detected).
@@ -31,10 +32,11 @@ Extensions: `.dylib` (sharedlib), `.a` (staticlib).
 ### Windows

 ```
-target/<profile>/
+target/<profile>/ (default) or target/<triple>/<profile>/ (with target)
 ```

 Architectures: `x86_64`, `aarch64`.
+Environments: `msvc` (default), `gnu` (MinGW).

 Extensions: `.exe` (bin), `.lib` (staticlib), `.dll` (sharedlib), `.efi` (UEFI).

--- a/docs/reference/workspaces.mdx
+++ b/docs/reference/workspaces.mdx
@@ -43,7 +43,9 @@ dcr build                    # build all packages in dependency order
 dcr build --workspace app    # build only app (dependencies built automatically)
 ```

-When building a workspace, member outputs (libraries) are automatically added to include/lib paths of dependent packages.
+When building a workspace, DCR automatically injects include and library paths of dependent workspace members:
+- **Include Paths**: Automatically resolves and injects header directories of dependencies, including the member's `src/` directory, local `include/` directory, and the packaged `target/include` directory.
+- **Library Paths**: Injects compiled library search paths (`target/lib` as well as target-specific build folders) to allow automatic linking with member libraries.

 ## Clean

--- a/man/man1/dcr-build.1
+++ b/man/man1/dcr-build.1
@@ -1,4 +1,4 @@
-.TH DCR-BUILD 1 "2026-06-02" "dcr 0.7.0" "DCR Manual"
+.TH DCR-BUILD 1 "2026-08-04" "dcr 0.8.4" "DCR Manual"
 .SH NAME
 dcr-build \- Compile a DCR project
 .SH SYNOPSIS
@@ -9,8 +9,15 @@ dcr-build \- Compile a DCR project
 [\fB\-\-clean\fR]
 [\fB\-\-verbose\fR]
 [\fB\-\-workspace\fR \fI<name>\fR]
+[\fB\-\-print\-artifact\-path\fR]
 .SH DESCRIPTION
-Compiles the project. Default profile is \fB\-\-debug\fR.
+Compiles the project. Default profile is
+.B \-\-debug .
+On success, updates
+.B .dcr/build-info.json
+and
+.B .dcr/toolchain.json
+when applicable.
 .SH OPTIONS
 .TP
 .B \-\-debug
@@ -33,5 +40,9 @@ Print detailed build output including compiler commands.
 .TP
 .B \-\-workspace \fI<name>\fR
 Build a specific workspace member.
+.TP
+.B \-\-print\-artifact\-path
+After a successful build, print the absolute path of the main artifact as a single line on stdout.
 .SH SEE ALSO
-.BR dcr (1)
+.BR dcr (1),
+.BR dcr-gen (1)
--- a/man/man1/dcr-gen.1
+++ b/man/man1/dcr-gen.1
@@ -1,23 +1,67 @@
-.TH DCR-GEN 1 "2026-06-02" "dcr 0.7.0" "DCR Manual"
+.TH DCR-GEN 1 "2026-08-04" "dcr 0.8.4" "DCR Manual"
 .SH NAME
 dcr-gen \- Generate IDE and tooling integration files
 .SH SYNOPSIS
 .B dcr gen \fI<subcommand>\fR
+[\fB\-\-debug\fR | \fB\-\-release\fR]
+[\fB\-\-quiet\fR | \fB\-q\fR]
 .SH DESCRIPTION
 Generates IDE and tooling integration files for DCR projects.
+Machine-readable build facts are written under
+.B .dcr/
+(compile database, build-info, toolchain).
 .SH SUBCOMMANDS
 .TP
 .B project-info
-Print project metadata as JSON to stdout.
+Print project metadata as JSON to stdout (absolute paths, artifact_path, target_dir).
+Also updates
+.B .dcr/build-info.json
+and
+.B .dcr/toolchain.json .
 .TP
 .B compile-commands
-Generate \fBcompile_commands.json\fR for IDE tooling.
+Generate
+.B .dcr/compile_commands.json
+(atomic write) and ensure
+.B .clangd
+points at
+.B .dcr
+as CompilationDatabase.
 .TP
 .B vscode
-Generate \fB.vscode/\fR integration files (tasks, launch configurations).
+Generate
+.B .vscode/
+integration files (tasks, launch configurations) and compile commands under
+.B .dcr/ .
 .TP
 .B clion
-Generate \fB.idea/\fR integration files for CLion.
+Generate
+.B .idea/
+integration files for CLion and compile commands under
+.B .dcr/ .
+.SH OPTIONS
+.TP
+.B \-\-debug
+Use debug profile (default).
+.TP
+.B \-\-release
+Use release profile.
+.TP
+.B \-\-quiet\fR, \fB\-q
+Suppress human-readable success messages on stdout.
+.SH FILES
+.TP
+.B .dcr/compile_commands.json
+JSON Compilation Database (moved from project root; breaking change in 0.8.4).
+.TP
+.B .dcr/build-info.json
+Last known artifact path, profile, compiler.
+.TP
+.B .dcr/toolchain.json
+Resolved compiler/debugger (and Qt tools if configured).
+.TP
+.B .clangd
+Created once with CompilationDatabase: .dcr; not overwritten if customized.
 .SH SEE ALSO
 .BR dcr (1),
 .BR dcr-build (1)
--- a/man/man1/dcr-run.1
+++ b/man/man1/dcr-run.1
@@ -8,9 +8,13 @@ dcr-run \- Build and run a DCR project
 [\fB\-\-force\fR]
 [\fB\-\-clean\fR]
 [\fB\-\-verbose\fR]
+[\fB\-\-\fR \fI<args>...\fR]
 .SH DESCRIPTION
 Builds and runs the project. Only available for projects with
 \fBkind = "bin"\fR.
+Arguments after a bare
+.B \-\-
+are forwarded to the built binary (cargo-style).
 .SH OPTIONS
 .TP
 .B \-\-debug
@@ -30,6 +34,14 @@ Clean before building.
 .TP
 .B \-\-verbose
 Print detailed build output.
+.TP
+.B \-\- \fI<args>...\fR
+Arguments passed to the built binary.
+.SH EXAMPLES
+.nf
+dcr run --release -- --test_help
+dcr run -- --foo bar
+.fi
 .SH SEE ALSO
 .BR dcr (1),
 .BR dcr-build (1)
--- a/man/man1/dcr.1
+++ b/man/man1/dcr.1
@@ -38,11 +38,14 @@ Display the dependency tree of the current project.
 .B fmt
 Format all C/C++ source files using clang-format.
 .TP
+.B lint [\fI\-\-fix\fR]
+Run clang-tidy static analysis on C/C++ sources.
+.TP
 .B gen \fI<subcommand>\fR
 Generate IDE integration files (vscode, clion, compile-commands, project-info).
 .TP
 .B setup
-Set up DCR registries for dependency resolution.
+Show configured package registries.
 .SH GLOBAL FLAGS
 .TP
 .B \-\-help
@@ -125,7 +128,7 @@ Version from registry (e.g. \fB1.2.3\fR).
 Print project metadata as JSON to stdout.
 .TP
 .B compile-commands
-Generate \fBcompile_commands.json\fR for IDE tooling.
+Generate \fB.dcr/compile_commands.json\fR for IDE tooling.
 .TP
 .B vscode
 Generate \fB.vscode/\fR integration files (tasks, launch configurations).
@@ -151,6 +154,11 @@ Project name (required).
 .B package.version
 Project version (default: \fB0.1.0\fR).
 .TP
+.B package.dcr\-version
+Semver of the DCR tool this project targets. Set automatically by
+\fBdcr new\fR / \fBdcr init\fR. Missing pin, or an installed \fBdcr\fR older/newer
+than the pin, prints a warning (commands still run).
+.TP
 .B build.language
 Programming language: \fBc\fR or \fBc++\fR (default: \fBc\fR).
 .TP
--- a/src/cli/add.rs
+++ b/src/cli/add.rs
@@ -23,16 +23,38 @@ use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, colored, printc};
 use toml::Value;
 use toml::map::Map;

+/// Parsed arguments for the `dcr add` command.
+///
+/// Exactly one of `path`, `git`, or `version_from_registry` is expected to be set,
+/// depending on how the dependency source was specified.
 pub struct AddArgs {
+    /// Dependency name as it will appear under `[dependencies]` in `dcr.toml`.
    pub name: String,
+    /// Local filesystem path when the source uses the `path:` prefix.
    pub path: Option<String>,
+    /// Git repository URL when the source is a git/GitHub/GitLab URL or prefix.
    pub git: Option<String>,
+    /// Optional git branch to pin the dependency to.
    pub branch: Option<String>,
+    /// Optional git tag to pin the dependency to.
    pub tag: Option<String>,
+    /// Optional git commit hash (revision) to pin the dependency to.
    pub rev: Option<String>,
+    /// Version string resolved from the package registry when no explicit source is given.
    pub version_from_registry: Option<String>,
 }

+/// Adds a dependency to the current project's `dcr.toml`.
+///
+/// Parses CLI arguments, locates the project root, builds a TOML dependency value
+/// (path, git with optional ref, or registry version), and writes it under
+/// `dependencies.<name>`.
+///
+/// # Parameters
+/// - `args`: Tokens after `dcr add` (name, source, optional `--branch`/`--tag`/`--rev`).
+///
+/// # Returns
+/// Process exit code: `0` on success, non-zero on usage or I/O errors.
 pub fn add(args: &[String]) -> i32 {
    if args.first().is_some_and(|a| a == "--help") {
        printc("USAGE:", BOLD_GREEN);
@@ -91,6 +113,7 @@ pub fn add(args: &[String]) -> i32 {
        }
    };

+    // Build the TOML value written under dependencies.<name>
    let dep_value = if let Some(git_url) = add_args.git {
        if add_args.branch.is_none() && add_args.tag.is_none() && add_args.rev.is_none() {
            let mut table = Map::new();
@@ -135,6 +158,11 @@ pub fn add(args: &[String]) -> i32 {
    0
 }

+/// Parses CLI arguments into an [`AddArgs`] value.
+///
+/// Expects `<name> [source] [--branch|--tag|--rev ...]`. If `source` is omitted,
+/// the package registry is queried for a default version. Source strings may use
+/// `path:`, `github:`, `gitlab:`, or `git:` prefixes, or a full git URL.
 fn parse_add_args(args: &[String]) -> Result<AddArgs, i32> {
    if args.is_empty() {
        error("Usage: dcr add <name> <source> [--branch <branch> | --tag <tag> | --rev <rev>]");
@@ -168,7 +196,7 @@ fn parse_add_args(args: &[String]) -> Result<AddArgs, i32> {
        }
        source_spec = s.clone();
    } else {
-        // No source provided — try registry auto-lookup
+        // No source provided — resolve version from the package registry
        match register::resolve_package_from_registry(&name) {
            Ok(info) => {
                let version = info
@@ -235,6 +263,7 @@ fn parse_add_args(args: &[String]) -> Result<AddArgs, i32> {
    let mut path = None;
    let mut git = None;

+    // Map source prefixes / bare URLs to path or git fields
    if let Some(p) = source_spec.strip_prefix("path:") {
        path = Some(p.to_string());
    } else if let Some(g) = source_spec.strip_prefix("github:") {
@@ -243,10 +272,10 @@ fn parse_add_args(args: &[String]) -> Result<AddArgs, i32> {
        git = Some(format!("https://gitlab.com/{}", g));
    } else if let Some(g) = source_spec.strip_prefix("git:") {
        if g.contains('/') && !g.contains('.') {
-            // git:user/repo -> default to github
+            // git:user/repo with no host — default to GitHub
            git = Some(format!("https://github.com/{}", g));
        } else {
-            // git:host.com/user/repo
+            // git:host.com/user/repo or an already-qualified URL
            let url = if g.starts_with("http") || g.starts_with("git@") {
                g.to_string()
            } else {
--- a/src/cli/build.rs
+++ b/src/cli/build.rs
@@ -17,19 +17,49 @@

 use crate::cli::clean::clean;
 use crate::cli::flags::parse_build_run_flags;
+use crate::cli::r#gen::{ProjectInfo, write_dcr_metadata};
+use crate::core::build::builder::artifact::{absolute_artifact_path, resolve_artifact_path};
+use crate::core::build::common;
 use crate::core::build::{BuildEvent, BuildReporter, BuildRequest, run_build};
 use crate::core::build_config::Config;
-use crate::utils::build::default_target_triple;
-use crate::utils::fs::find_project_root;
+use crate::utils::build::{
+    get_config_opt, get_config_str, get_language_with_profile_or_default, get_string_with_profile,
+    normalize_kind, resolve_artifact_target_dir, resolve_compiler,
+};
+use crate::utils::fs::{canonicalize_path, find_project_root};
 use crate::utils::log::error;
-use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, colored, printc};
+use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, BOLD_YELLOW, colored, printc};
+use std::io::IsTerminal;
+use std::path::Path;
 use std::sync::{Arc, atomic::AtomicBool};

 pub use crate::core::build::get_build_string_with_profile;

+/// Formats a left-aligned status verb with the given style for CLI output.
+fn status(verb: &str, style: &str) -> String {
+    colored(&format!("{verb:<9}"), style)
+}
+
+/// CLI build reporter that prints human-readable progress to stderr/stdout.
 struct CliReporter;

+impl CliReporter {
+    /// Prints a single status line with a styled verb and free-form rest text.
+    ///
+    /// # Parameters
+    /// - `verb`: Short status label (e.g. `"target"`, `"dep"`).
+    /// - `style`: Color/style constant for the verb.
+    /// - `rest`: Remaining message text after the verb.
+    fn line(&self, verb: &str, style: &str, rest: &str) {
+        eprintln!("  {} {}", status(verb, style), rest);
+    }
+}
+
 impl BuildReporter for CliReporter {
+    /// Handles build events by printing progress, status lines, and compiler output.
+    ///
+    /// # Parameters
+    /// - `event`: Build pipeline event to report to the user.
    fn on_event(&mut self, event: BuildEvent<'_>) {
        match event {
            BuildEvent::TargetStart {
@@ -37,84 +67,82 @@ impl BuildReporter for CliReporter {
                total,
                target,
            } => {
-                println!("    Building target {} of {}: {}", index, total, target);
+                common::finish_progress_line();
+                self.line("target", BOLD_CYAN, &format!("{index}/{total}  {target}"));
            }
            BuildEvent::ProjectStart {
                name,
                profile,
                target,
            } => {
-                println!(
-                    "    Building project `{}`\n    Profile: {}\n      Target: {}",
-                    colored(name, BOLD_GREEN),
-                    colored(profile, BOLD_GREEN),
-                    colored(target, BOLD_GREEN)
+                common::finish_progress_line();
+                self.line(
+                    "project",
+                    BOLD_CYAN,
+                    &format!("{name}  ({profile}, {target})"),
                );
            }
            BuildEvent::DepBuilding { name, version } => {
-                print!(
-                    "\r{:100}\r      {} {} v{}",
-                    "",
-                    colored("Building", BOLD_GREEN),
-                    name,
-                    version
-                );
-                std::io::Write::flush(&mut std::io::stdout()).unwrap();
+                common::finish_progress_line();
+                self.line("dep", BOLD_YELLOW, &format!("{name} v{version}"));
            }
            BuildEvent::DepReady {
                name,
                version,
                rebuilt,
            } => {
+                common::finish_progress_line();
+                // Only announce deps that were actually rebuilt this run.
                if rebuilt {
-                    print!(
-                        "\r{:100}\r       {} {} v{}",
-                        "",
-                        colored("Ready", BOLD_GREEN),
-                        name,
-                        version
-                    );
-                    println!();
-                } else {
-                    println!(
-                        "      {} {} v{}",
-                        colored("Ready", BOLD_GREEN),
-                        name,
-                        version
-                    );
+                    self.line("ready", BOLD_GREEN, &format!("{name} v{version}"));
                }
            }
            BuildEvent::Compiling { name, version } => {
-                println!(
-                    "   {} {} v{}",
-                    colored("Compiling", BOLD_GREEN),
-                    name,
-                    version
-                );
+                common::finish_progress_line();
+                let label = format!("  {} {} v{}", status("compile", BOLD_GREEN), name, version);
+                // Terminals use an in-place progress line; non-TTY gets a plain log line.
+                common::set_progress_label(Some(label.clone()));
+                if !std::io::stderr().is_terminal() {
+                    eprintln!("{label}");
+                }
+            }
+            BuildEvent::Packing { path } => {
+                common::finish_progress_line();
+                self.line("pack", BOLD_CYAN, path);
            }
            BuildEvent::Finished { secs } => {
-                println!(
-                    "    {} Build completed successfully in {} seconds",
-                    colored("✔", BOLD_GREEN),
-                    colored(&secs.to_string(), BOLD_GREEN)
-                );
+                common::finish_progress_line();
+                self.line("done", BOLD_GREEN, &format!("in {secs}s"));
            }
            BuildEvent::CompilerOutput { stream, text } => {
+                // Pause the progress spinner so compiler text is not overwritten.
+                common::interrupt_progress_for_output();
                if stream == "stderr" {
-                    eprintln!("{}", text);
+                    eprint!("{text}");
                } else {
-                    println!("{}", text);
+                    print!("{text}");
                }
            }
        }
    }
 }

+/// Runs the project build command from the CLI.
+///
+/// Parses flags, locates the project root, optionally cleans, then invokes the
+/// core build pipeline. On success, may write `.dcr` metadata and print the
+/// main artifact path when requested.
+///
+/// # Parameters
+/// - `args`: Tokens after `dcr build` (profile, target, force, clean, etc.).
+///
+/// # Returns
+/// Process exit code: `0` on success or help, non-zero on failure.
 pub fn build(args: &[String]) -> i32 {
    if args.first().is_some_and(|a| a == "--help") {
        printc("USAGE:", BOLD_GREEN);
        printc(
-            "    dcr build [--debug | --release] [--target <triple>] [--force] [--clean] [--verbose]",
+            "    dcr build [--debug | --release] [--target <triple>] [--force] [--clean] [--verbose] [--print-artifact-path]",
            BOLD_CYAN,
        );
        println!();
@@ -129,9 +157,13 @@ pub fn build(args: &[String]) -> i32 {
        println!("    --clean              Clean before building");
        println!("    --verbose            Print detailed build output");
        println!("    --workspace <name>   Build a specific workspace member");
+        println!(
+            "    --print-artifact-path  Print absolute main artifact path on stdout after success"
+        );
        return 0;
    }

+    // Shared cancel flag so Ctrl-C can stop an in-progress build cooperatively.
    let cancel = Arc::new(AtomicBool::new(false));
    let cancel_clone = cancel.clone();
    ctrlc::set_handler(move || {
@@ -146,7 +178,7 @@ pub fn build(args: &[String]) -> i32 {
        }
    };
    let root = match find_project_root(&start_dir) {
-        Ok(Some(dir)) => dir,
+        Ok(Some(dir)) => canonicalize_path(&dir),
        Ok(None) => {
            error("dcr.toml file not found");
            return 1;
@@ -161,20 +193,18 @@ pub fn build(args: &[String]) -> i32 {
        Err(code) => return code,
    };

+    // Prefer CLI --target; otherwise fall back to profile target from dcr.toml.
    if flags.target.is_none() {
        let config_path = root.join("dcr.toml");
        if let Ok(config) = Config::open(config_path.to_str().unwrap())
            && !config.is_workspace_only()
        {
-            let bt = get_build_string_with_profile(&config, "target", "debug");
+            let bt = get_build_string_with_profile(&config, "target", &flags.profile);
            if !bt.is_empty() {
                flags.target = Some(bt);
            }
        }
    }
-    if flags.target.is_none() {
-        flags.target = Some(default_target_triple());
-    }
    if flags.clean {
        let mut clean_args = Vec::new();
        clean_args.push(format!("--{}", flags.profile));
@@ -182,19 +212,175 @@ pub fn build(args: &[String]) -> i32 {
    }

    let req = BuildRequest {
-        profile: flags.profile,
-        target: flags.target,
+        profile: flags.profile.clone(),
+        target: flags.target.clone(),
        force: flags.force,
        verbose: flags.verbose,
-        workspace: flags.workspace,
+        workspace: flags.workspace.clone(),
        cancel,
    };
    let mut reporter = CliReporter;
    match run_build(&root, &req, &mut reporter) {
-        Ok(_) => 0,
+        Ok(_) => {
+            // Persist IDE/metadata and optionally echo the main artifact path.
+            if let Some(info) =
+                resolve_post_build_info(&root, &flags.profile, flags.target.as_deref())
+            {
+                let _ = write_dcr_metadata(&root, &info);
+                if flags.print_artifact_path
+                    && let Some(ref path) = info.artifact_path
+                {
+                    println!("{path}");
+                }
+            } else if flags.print_artifact_path
+                && let Some(path) =
+                    fallback_artifact_path(&root, &flags.profile, flags.target.as_deref())
+            {
+                println!("{path}");
+            }
+            0
+        }
        Err(err) => {
+            common::finish_progress_line();
            error(&err.message);
            1
        }
    }
 }
+
+/// Collects project and artifact metadata after a successful build.
+///
+/// Reads `dcr.toml`, resolves language/compiler/kind/target/output settings for
+/// the given profile, and computes absolute artifact and target directory paths.
+///
+/// # Parameters
+/// - `root`: Project root with `dcr.toml`.
+/// - `profile`: Build profile used for the just-finished build.
+/// - `cli_target`: Optional target from the CLI (overrides config when set).
+///
+/// # Returns
+/// `Some(ProjectInfo)` for a normal package; `None` for workspace-only roots
+/// or when required config/paths cannot be resolved.
+fn resolve_post_build_info(
+    root: &Path,
+    profile: &str,
+    cli_target: Option<&str>,
+) -> Option<ProjectInfo> {
+    let config = Config::open(root.join("dcr.toml").to_str()?).ok()?;
+    if config.is_workspace_only() {
+        return None;
+    }
+    let name = get_config_str(&config, "package.name");
+    let version = get_config_str(&config, "package.version");
+    let language = get_language_with_profile_or_default(&config, profile);
+    let standard = get_string_with_profile(&config, "standard", profile);
+    let cxx_standard = get_string_with_profile(&config, "cxx_standard", profile);
+    let compiler_s = get_string_with_profile(&config, "compiler", profile);
+    let kind = normalize_kind(&get_string_with_profile(&config, "kind", profile)).to_string();
+    let build_target = cli_target
+        .map(|s| s.to_string())
+        .filter(|s| !s.is_empty())
+        .unwrap_or_else(|| get_string_with_profile(&config, "target", profile));
+    let output_filename_s = get_string_with_profile(&config, "filename", profile);
+    let output_extension_s = get_string_with_profile(&config, "extension", profile);
+    let output_filename = if output_filename_s.is_empty() {
+        None
+    } else {
+        Some(output_filename_s)
+    };
+    let output_extension = if output_extension_s.is_empty() {
+        None
+    } else {
+        Some(output_extension_s)
+    };
+    let tc_cc = get_config_opt(&config, "toolchain.cc");
+    let tc_cxx = get_config_opt(&config, "toolchain.cxx");
+    let tc_as = get_config_opt(&config, "toolchain.as");
+    let resolved_compiler = resolve_compiler(
+        &language,
+        &compiler_s,
+        tc_cc.as_deref(),
+        tc_cxx.as_deref(),
+        tc_as.as_deref(),
+    );
+    let out_dir = get_string_with_profile(&config, "out_dir", profile);
+    // Explicit target (CLI or config) changes how the artifact directory is laid out.
+    let has_explicit = cli_target.is_some_and(|t| !t.is_empty()) || !build_target.trim().is_empty();
+    let target_dir =
+        resolve_artifact_target_dir(root, None, profile, &build_target, &out_dir, has_explicit);
+    let rel = resolve_artifact_path(
+        &kind,
+        profile,
+        &name,
+        Some(&target_dir),
+        output_filename.as_deref(),
+        output_extension.as_deref(),
+    )?;
+    let artifact_path = absolute_artifact_path(root, &rel)
+        .to_string_lossy()
+        .to_string();
+    let abs_target_dir = {
+        let p = Path::new(&target_dir);
+        let path = if p.is_absolute() {
+            canonicalize_path(p)
+        } else {
+            canonicalize_path(&root.join(p))
+        };
+        path.to_string_lossy().into_owned()
+    };
+    Some(ProjectInfo {
+        name,
+        version,
+        root: root.to_path_buf(),
+        profile: profile.to_string(),
+        language,
+        standard,
+        cxx_standard,
+        compiler: resolved_compiler,
+        kind: kind.clone(),
+        target: build_target,
+        target_dir: Some(abs_target_dir),
+        artifact_path: Some(artifact_path),
+        artifact_kind: kind,
+        sources: vec![],
+        include_dirs: vec![],
+        lib_dirs: vec![],
+        libs: vec![],
+        cflags: vec![],
+        ldflags: vec![],
+        source_roots: vec![],
+        include_globs: vec![],
+        exclude_globs: vec![],
+        output_filename,
+        output_extension,
+        out_dir,
+        debugger: "lldb".to_string(),
+        moc: None,
+        uic: None,
+        rcc: None,
+        workspace_root: None,
+    })
+}
+
+/// Best-effort absolute main artifact path when full post-build info is unavailable.
+///
+/// Assumes a binary (`"bin"`) kind and uses the package name plus profile,
+/// target, and `out_dir` settings from config.
+fn fallback_artifact_path(root: &Path, profile: &str, target: Option<&str>) -> Option<String> {
+    let config = Config::open(root.join("dcr.toml").to_str()?).ok()?;
+    let name = get_config_str(&config, "package.name");
+    if name.is_empty() {
+        return None;
+    }
+    let build_target = target.unwrap_or("").to_string();
+    let out_dir = get_string_with_profile(&config, "out_dir", profile);
+    let has_explicit = !build_target.trim().is_empty();
+    let target_dir =
+        resolve_artifact_target_dir(root, None, profile, &build_target, &out_dir, has_explicit);
+    let rel = resolve_artifact_path("bin", profile, &name, Some(&target_dir), None, None)?;
+    Some(
+        absolute_artifact_path(root, &rel)
+            .to_string_lossy()
+            .to_string(),
+    )
+}
--- a/src/cli/clean.rs
+++ b/src/cli/clean.rs
@@ -25,6 +25,15 @@ use glob::glob;
 use std::fs;
 use std::path::Path;

+/// Entry point for the `dcr clean` command.
+///
+/// Removes build artifacts from the project (and optionally workspace members).
+///
+/// # Parameters
+/// - `args`: Tokens after `dcr clean` (`--debug`/`--release`, `--target`, `--all`).
+///
+/// # Returns
+/// Process exit code: `0` on success, `1` on failure.
 pub fn clean(args: &[String]) -> i32 {
    if args.first().is_some_and(|a| a == "--help") {
        printc("USAGE:", BOLD_GREEN);
@@ -70,6 +79,7 @@ pub fn clean(args: &[String]) -> i32 {
        }
    };

+    // Run cleanup relative to the project root so paths resolve consistently.
    match with_dir(&root, || clean_from_root(&root, &flags)) {
        Ok(()) => 0,
        Err(msg) => {
@@ -79,12 +89,20 @@ pub fn clean(args: &[String]) -> i32 {
    }
 }

+/// Parsed flags controlling which artifacts `clean` should remove.
 struct CleanFlags {
+    /// Optional build profile name (e.g. `debug`, `release`).
    profile: Option<String>,
+    /// Optional target triple to clean under `target/<triple>/...`.
    target: Option<String>,
+    /// When true, also clean each workspace member that has a `target` directory.
    all: bool,
 }

+/// Parses CLI arguments into [`CleanFlags`].
+///
+/// Recognizes `--all`, `--target <triple>`, and profile flags such as `--debug`
+/// / `--release` (validated via [`default_profile_flags`]).
 fn parse_clean_flags(args: &[String]) -> Result<CleanFlags, String> {
    let mut profile: Option<String> = None;
    let mut target: Option<String> = None;
@@ -104,6 +122,7 @@ fn parse_clean_flags(args: &[String]) -> Result<CleanFlags, String> {
            continue;
        }
        if arg.starts_with("--") {
+            // Accept only known profile names (e.g. debug/release), not arbitrary flags.
            let candidate = arg.trim_start_matches("--").to_string();
            if !default_profile_flags(&candidate).is_empty() {
                if profile.is_some() {
@@ -122,20 +141,35 @@ fn parse_clean_flags(args: &[String]) -> Result<CleanFlags, String> {
    })
 }

+/// Cleans the project at `root`, and optionally all workspace members.
+///
+/// Resolves the effective target triple from flags, `dcr.toml`, or host defaults,
+/// then removes the appropriate `target` subdirectories and custom clean paths.
 fn clean_from_root(root: &Path, flags: &CleanFlags) -> Result<(), String> {
    let config = Config::open("./dcr.toml").map_err(|err| err.to_string())?;

-    let target = flags
-        .target
-        .clone()
-        .or_else(|| {
-            config
-                .get("build.target")
-                .and_then(|v| v.as_str())
-                .map(|s| s.trim().to_string())
-                .filter(|s| !s.is_empty())
-        })
-        .or_else(|| Some(default_target_triple()));
+    // Prefer CLI --target, then build.target from config, then host defaults on Linux/BSD.
+    let target = flags.target.clone().or_else(|| {
+        config
+            .get("build.target")
+            .and_then(|v| v.as_str())
+            .map(|s| s.trim().to_string())
+            .filter(|s| !s.is_empty())
+    });
+    let target = match target {
+        Some(t) => Some(crate::utils::build::normalize_target_os(&t).to_string()),
+        None if cfg!(target_os = "linux")
+            || cfg!(any(
+                target_os = "freebsd",
+                target_os = "openbsd",
+                target_os = "netbsd",
+                target_os = "dragonfly"
+            )) =>
+        {
+            Some(default_target_triple())
+        }
+        None => None,
+    };

    if flags.all
        && let Some(workspace) = parse_workspace(
@@ -146,12 +180,21 @@ fn clean_from_root(root: &Path, flags: &CleanFlags) -> Result<(), String> {
        )?
    {
        for member in &workspace.members {
-            clean_project_at(&member.path, flags.profile.as_deref(), target.as_deref())?;
+            let member_target = member.path.join("target");
+            if member_target.is_dir() {
+                clean_project_at(&member.path, flags.profile.as_deref(), target.as_deref())?;
+            }
        }
    }
    clean_project_at(root, flags.profile.as_deref(), target.as_deref())
 }

+/// Removes build artifacts for a single project directory.
+///
+/// When `profile` is set, only that profile's directory under `target` (optionally
+/// scoped by `target` triple) is removed, plus custom paths for that profile.
+/// When `profile` is `None`, the entire `target` tree is removed and custom paths
+/// are cleaned for both `debug` and `release`.
 fn clean_project_at(
    project_root: &Path,
    profile: Option<&str>,
@@ -179,6 +222,7 @@ fn clean_project_at(
            };
            let target_items = check_dir(Some("target")).unwrap_or_default();
            let parent_dir = target.unwrap_or("");
+            // Existence check differs: with a triple, look for target/<triple>; otherwise target/<profile>.
            let dir_exists = if target.is_some() {
                target_items.contains(&parent_dir.to_string())
            } else {
@@ -217,6 +261,10 @@ fn clean_project_at(
    })
 }

+/// Deletes extra paths listed under `build.clean` in `dcr.toml` for a profile.
+///
+/// Each pattern may contain `{profile}` and version placeholders, which are
+/// expanded before matching with `glob`. Matched files and directories are removed.
 fn clean_custom_paths(config: &Config, profile: &str) -> Result<(), String> {
    let patterns = match config.get("build.clean") {
        Some(v) => v
@@ -247,6 +295,10 @@ fn clean_custom_paths(config: &Config, profile: &str) -> Result<(), String> {
    Ok(())
 }

+/// Expands version-related placeholders in a clean path pattern.
+///
+/// Reads `package.version` from `config`, parses it, and applies
+/// [`crate::utils::build::substitute_version_vars`].
 fn substitute_clean_vars(value: &str, config: &Config) -> String {
    let version = config
        .get("package.version")
--- a/src/cli/flag_update.rs
+++ b/src/cli/flag_update.rs
@@ -27,18 +27,32 @@ use std::time::{SystemTime, UNIX_EPOCH};

 const LATEST_RELEASE_URL: &str = "https://api.github.com/repos/dexoron/dcr/releases/latest";

+/// Metadata for the latest GitHub release of DCR.
 #[derive(Debug, Deserialize)]
 struct Release {
+    /// Release tag, typically including a leading `v` (e.g. `v1.2.3`).
    tag_name: String,
+    /// Downloadable assets attached to the release.
    assets: Vec<ReleaseAsset>,
 }

+/// A single downloadable asset from a GitHub release.
 #[derive(Debug, Deserialize)]
 struct ReleaseAsset {
+    /// Asset file name as published on GitHub.
    name: String,
+    /// Direct URL used to download the asset.
    browser_download_url: String,
 }

+/// Handles the `dcr --update` flag: checks GitHub for a newer release and
+/// replaces the running binary when an update is available.
+///
+/// # Parameters
+/// - `args`: Remaining tokens after `--update` (only `--help` is accepted).
+///
+/// # Returns
+/// `0` on success / already up to date / pacman-managed refuse; `1` on error.
 pub fn flag_update(args: &[String]) -> i32 {
    if args.first().is_some_and(|a| a == "--help") {
        printc("USAGE:", BOLD_GREEN);
@@ -62,6 +76,7 @@ pub fn flag_update(args: &[String]) -> i32 {
        }
    };

+    // Refuse self-update when the binary is owned by pacman/AUR.
    if let Some(package_name) = pacman_owned_package(&current_exe) {
        warn("This dcr binary is managed by pacman/AUR");
        println!(
@@ -81,6 +96,7 @@ pub fn flag_update(args: &[String]) -> i32 {
        }
    };

+    // Normalize the tag by stripping a leading `v` before comparison.
    let latest_version = release.tag_name.trim_start_matches('v');
    if latest_version == current_version {
        println!("Latest version is already installed: {current_version}");
@@ -113,6 +129,7 @@ pub fn flag_update(args: &[String]) -> i32 {
    }
    set_executable_permissions(&temp_path);

+    // Replace the running executable in place, then clean up the temp file.
    if self_replace::self_replace(&temp_path).is_err() {
        let _ = fs::remove_file(&temp_path);
        error("Failed to replace current binary");
@@ -124,6 +141,7 @@ pub fn flag_update(args: &[String]) -> i32 {
    0
 }

+/// Fetches the latest DCR release metadata from the GitHub Releases API.
 fn fetch_latest_release() -> Result<Release, String> {
    let response = ureq::get(LATEST_RELEASE_URL)
        .set("User-Agent", "dcr-updater")
@@ -138,6 +156,7 @@ fn fetch_latest_release() -> Result<Release, String> {
        .map_err(|_| "GitHub API response has an unexpected format".to_string())
 }

+/// Downloads a release asset from the given URL into memory.
 fn download_asset(url: &str) -> Result<Vec<u8>, String> {
    let response = ureq::get(url)
        .set("User-Agent", "dcr-updater")
@@ -155,9 +174,11 @@ fn download_asset(url: &str) -> Result<Vec<u8>, String> {
    Ok(data)
 }

+/// Builds the list of expected asset file names for the given build target.
 fn asset_candidates(target: &str) -> Vec<String> {
    let mut names = vec![format!("dcr-{target}")];

+    // Windows releases may publish the binary with an `.exe` suffix.
    if target.contains("-windows-") || target.ends_with("-windows") {
        names.push(format!("dcr-{target}.exe"));
    }
@@ -165,6 +186,7 @@ fn asset_candidates(target: &str) -> Vec<String> {
    names
 }

+/// Creates a unique temporary path next to the current executable for the download.
 fn temp_binary_path(current_exe: &Path) -> PathBuf {
    let stamp = SystemTime::now()
        .duration_since(UNIX_EPOCH)
@@ -177,6 +199,7 @@ fn temp_binary_path(current_exe: &Path) -> PathBuf {
    current_exe.with_extension(extension)
 }

+/// Sets executable permissions on Unix; no-op on other platforms.
 fn set_executable_permissions(_path: &Path) {
    #[cfg(unix)]
    {
@@ -189,6 +212,7 @@ fn set_executable_permissions(_path: &Path) {
    }
 }

+/// On Linux, returns the pacman package that owns `path`, if any.
 #[cfg(target_os = "linux")]
 fn pacman_owned_package(path: &Path) -> Option<String> {
    let output = Command::new("pacman").arg("-Qoq").arg(path).output().ok()?;
@@ -204,6 +228,7 @@ fn pacman_owned_package(path: &Path) -> Option<String> {
    Some(package_name)
 }

+/// Non-Linux stub: package-manager ownership is not checked.
 #[cfg(not(target_os = "linux"))]
 fn pacman_owned_package(_path: &Path) -> Option<String> {
    None
--- a/src/cli/flags.rs
+++ b/src/cli/flags.rs
@@ -18,25 +18,69 @@
 use crate::config::{PROFILE, flags};
 use crate::utils::log::warn;

+/// Flags shared by the `build` and `run` CLI commands.
 pub struct BuildRunFlags {
+    /// Build profile name (for example `debug` or `release`).
    pub profile: String,
+    /// Optional target triple or platform name.
    pub target: Option<String>,
+    /// Optional workspace member name (`--workspace <name>`).
    pub workspace: Option<String>,
+    /// Force a rebuild even when artifacts appear up to date.
    pub force: bool,
+    /// Clean build outputs before building.
    pub clean: bool,
+    /// Enable verbose logging during the build or run.
    pub verbose: bool,
+    /// Print the final artifact path to the user.
+    pub print_artifact_path: bool,
+    /// Arguments forwarded to the binary after a `--` separator.
+    pub bin_args: Vec<String>,
 }

+/// Splits CLI arguments at the first `--` separator.
+///
+/// Everything before `--` is treated as DCR flags; everything after is
+/// forwarded to the built binary as `bin_args`.
+///
+/// # Parameters
+/// - `args`: Full argument list for the command (without the program name).
+///
+/// # Returns
+/// `(dcr_args, bin_args)`. If `--` is absent, `bin_args` is empty.
+pub fn split_double_dash(args: &[String]) -> (&[String], &[String]) {
+    match args.iter().position(|a| a == "--") {
+        Some(i) => (&args[..i], &args[i + 1..]),
+        None => (args, &[]),
+    }
+}
+
+/// Parses build/run flags from a list of CLI arguments.
+///
+/// Recognizes boolean flags (`--force`, `--clean`, `--verbose`,
+/// `--print-artifact-path`), value flags (`--workspace`, `--target`), and
+/// profile names registered via [`flags`]. Arguments after `--` become
+/// [`BuildRunFlags::bin_args`].
+///
+/// # Parameters
+/// - `args`: CLI arguments for build/run (may include `--`).
+///
+/// # Returns
+/// - `Ok(BuildRunFlags)` on success.
+/// - `Err(1)` for unknown flags, missing values, or a duplicate profile.
 pub fn parse_build_run_flags(args: &[String]) -> Result<BuildRunFlags, i32> {
+    let (dcr_args, bin_args_slice) = split_double_dash(args);
    let mut profile = PROFILE.to_string();
    let mut target = None;
    let mut workspace = None;
    let mut force = false;
    let mut clean = false;
    let mut verbose = false;
-    let mut iter = args.iter();
+    let mut print_artifact_path = false;
+    let mut iter = dcr_args.iter();

    while let Some(arg) = iter.next() {
+        // DCR build/run options are long flags only (`--name`).
        if !arg.starts_with("--") {
            warn("Unknown argument");
            return Err(1);
@@ -54,6 +98,10 @@ pub fn parse_build_run_flags(args: &[String]) -> Result<BuildRunFlags, i32> {
            verbose = true;
            continue;
        }
+        if candidate == "print-artifact-path" {
+            print_artifact_path = true;
+            continue;
+        }
        if candidate == "workspace" {
            if let Some(w) = iter.next() {
                workspace = Some(w.clone());
@@ -72,6 +120,7 @@ pub fn parse_build_run_flags(args: &[String]) -> Result<BuildRunFlags, i32> {
            }
            continue;
        }
+        // Profile names come from config::flags; only one profile may be set.
        if flags(candidate).is_some() {
            if profile != PROFILE {
                warn("Duplicate profile flag");
@@ -91,5 +140,43 @@ pub fn parse_build_run_flags(args: &[String]) -> Result<BuildRunFlags, i32> {
        force,
        clean,
        verbose,
+        print_artifact_path,
+        bin_args: bin_args_slice.to_vec(),
    })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Converts string literals into owned `String` CLI arguments for tests.
+    fn s(args: &[&str]) -> Vec<String> {
+        args.iter().map(|a| a.to_string()).collect()
+    }
+
+    /// Checks that without `--`, the full list stays on the DCR side.
+    #[test]
+    fn split_double_dash_empty_tail() {
+        let args = s(&["--release", "--force"]);
+        let (left, right) = split_double_dash(&args);
+        assert_eq!(left, &s(&["--release", "--force"]));
+        assert!(right.is_empty());
+    }
+
+    /// Checks that arguments after `--` are split into the bin-args slice.
+    #[test]
+    fn split_double_dash_with_bin_args() {
+        let args = s(&["--release", "--", "--test_help", "x"]);
+        let (left, right) = split_double_dash(&args);
+        assert_eq!(left, &s(&["--release"]));
+        assert_eq!(right, &s(&["--test_help", "x"]));
+    }
+
+    /// Checks profile parsing and that bin args after `--` are forwarded.
+    #[test]
+    fn parse_run_flags_forwards_after_double_dash() {
+        let flags = parse_build_run_flags(&s(&["--release", "--", "--test_help"])).unwrap();
+        assert_eq!(flags.profile, "release");
+        assert_eq!(flags.bin_args, s(&["--test_help"]));
+    }
+}
--- a/src/cli/fmt.rs
+++ b/src/cli/fmt.rs
@@ -20,6 +20,12 @@ use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, colored, printc};
 use glob::glob;
 use std::process::Command;

+/// Formats all C/C++ source files using clang-format.
+///
+/// Scans the `src/` and `tests/` directories recursively for files with common
+/// C/C++ extensions and formats them in place with clang-format.
+///
+/// If the first argument is `--help`, prints usage information and returns 0.
 pub fn fmt(args: &[String]) -> i32 {
    if args.first().is_some_and(|a| a == "--help") {
        printc("USAGE:", BOLD_GREEN);
@@ -31,6 +37,7 @@ pub fn fmt(args: &[String]) -> i32 {
        return 0;
    }

+    // Collect all matching files from src/ and tests/ using glob patterns
    let patterns = [
        "src/**/*.c",
        "src/**/*.cpp",
@@ -66,6 +73,7 @@ pub fn fmt(args: &[String]) -> i32 {
        return 0;
    }

+    // Format the collected files
    println!(
        "    {} {} files",
        colored("Formatting", BOLD_GREEN),
--- a/src/cli/gen.rs
+++ b/src/cli/gen.rs
@@ -16,6 +16,7 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.

 use crate::core::build::builder::BuildContext;
+use crate::core::build::builder::artifact::{absolute_artifact_path, resolve_artifact_path};
 use crate::core::build::builder::collect_sources;
 use crate::core::build::common;
 use crate::core::build_config::Config;
@@ -23,21 +24,30 @@ use crate::core::workspace::parse_workspace;
 use crate::utils::build::{
    get_bool_with_profile, get_config_opt, get_config_str, get_language_with_profile_or_default,
    get_list_with_profile, get_string_with_profile, normalize_kind, normalize_platform,
-    normalize_target, resolve_compiler, resolve_pkg_config_flags_lossy,
+    resolve_artifact_target_dir, resolve_compiler, resolve_pkg_config_flags_lossy,
+};
+use crate::utils::fs::{
+    absolute_join, atomic_write, canonicalize_path, ensure_dcr_dir, find_project_root,
 };
-use crate::utils::fs::find_project_root;
 use crate::utils::log::error;
 use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, printc};
 use std::path::{Path, PathBuf};
+use std::time::{SystemTime, UNIX_EPOCH};

-/// Like `deps::resolve_deps` but does NOT require lib directories to exist.
-/// Used by `gen` commands where the project may not have been built yet.
+/// Path-dep include/lib/libs metadata for `dcr gen` (project may not be built yet).
+///
+/// Explicit include/lib lists may point at missing paths; default `include`/`lib`
+/// candidates are added only when those directories exist.
 struct GenDeps {
    include_dirs: Vec<String>,
    lib_dirs: Vec<String>,
    libs: Vec<String>,
 }

+/// Collects path-dependency include/lib/libs from `dcr.toml` for code generation.
+///
+/// Skips `system` deps and non-path entries. Falls back to common include/lib
+/// directory names only when those directories exist.
 fn resolve_deps_for_gen(config: &Config, profile: &str, project_root: &Path) -> GenDeps {
    let deps_val = match config.get("dependencies") {
        Some(v) => v,
@@ -164,7 +174,7 @@ fn resolve_deps_for_gen(config: &Config, profile: &str, project_root: &Path) ->

 // ── public API ───────────────────────────────────────────────────────────────

-/// Everything needed to generate output for one project member.
+/// Per-project (or workspace member) metadata collected for `dcr gen`.
 pub struct ProjectInfo {
    pub name: String,
    pub version: String,
@@ -175,16 +185,36 @@ pub struct ProjectInfo {
    pub cxx_standard: String,
    pub compiler: String,
    pub kind: String,
+    pub target: String,
+    pub target_dir: Option<String>,
+    pub artifact_path: Option<String>,
+    pub artifact_kind: String,
    pub sources: Vec<String>,
    pub include_dirs: Vec<String>,
    pub lib_dirs: Vec<String>,
    pub libs: Vec<String>,
    pub cflags: Vec<String>,
    pub ldflags: Vec<String>,
+    pub source_roots: Vec<String>,
+    pub include_globs: Vec<String>,
+    pub exclude_globs: Vec<String>,
+    pub output_filename: Option<String>,
+    pub output_extension: Option<String>,
+    pub out_dir: String,
+    pub debugger: String,
+    pub moc: Option<String>,
+    pub uic: Option<String>,
+    pub rcc: Option<String>,
+    pub workspace_root: Option<PathBuf>,
 }

-// ── entry-point for `dcr gen` ────────────────────────────────────────────────
-
+/// Entry point for `dcr gen`: dispatches to project-info / compile-commands / vscode / clion.
+///
+/// # Parameters
+/// - `args`: First token is the subcommand; the rest are subcommand flags.
+///
+/// # Returns
+/// Process exit code from the chosen subcommand (`0` for help).
 pub fn r#gen(args: &[String]) -> i32 {
    let subcommand = match args.first() {
        Some(s) if s == "--help" => {
@@ -196,9 +226,13 @@ pub fn r#gen(args: &[String]) -> i32 {
            println!();
            printc("SUBCOMMANDS:", BOLD_GREEN);
            println!("    project-info      Print project metadata as JSON");
-            println!("    compile-commands  Generate compile_commands.json");
+            println!("    compile-commands  Generate .dcr/compile_commands.json");
            println!("    vscode            Generate .vscode/ integration files");
            println!("    clion             Generate .idea/ integration files");
+            println!();
+            printc("OPTIONS:", BOLD_GREEN);
+            println!("    --debug | --release   Profile (default: debug)");
+            println!("    --quiet | -q          Suppress success messages on stdout");
            return 0;
        }
        Some(s) => s.as_str(),
@@ -208,7 +242,7 @@ pub fn r#gen(args: &[String]) -> i32 {
            println!();
            printc("SUBCOMMANDS:", BOLD_GREEN);
            println!("    project-info      Print project metadata as JSON");
-            println!("    compile-commands  Generate compile_commands.json");
+            println!("    compile-commands  Generate .dcr/compile_commands.json");
            println!("    vscode            Generate .vscode/ integration files");
            println!("    clion             Generate .idea/ integration files");
            return 1;
@@ -231,16 +265,28 @@ pub fn r#gen(args: &[String]) -> i32 {

 // ── shared: collect per-project data ─────────────────────────────────────────

-fn collect_project_info(root: &Path, profile: &str) -> Result<ProjectInfo, String> {
-    // Run from the project root so relative paths in dcr.toml resolve correctly.
+/// Collects [`ProjectInfo`] with cwd set to the project root so relative paths resolve.
+fn collect_project_info(
+    root: &Path,
+    profile: &str,
+    workspace_root: Option<&Path>,
+) -> Result<ProjectInfo, String> {
    let prev = std::env::current_dir().map_err(|e| e.to_string())?;
    std::env::set_current_dir(root).map_err(|e| e.to_string())?;
-    let result = collect_project_info_inner(root, profile);
+    let result = collect_project_info_inner(root, profile, workspace_root);
    let _ = std::env::set_current_dir(prev);
    result
 }

-fn collect_project_info_inner(root: &Path, profile: &str) -> Result<ProjectInfo, String> {
+/// Reads `dcr.toml` and resolves compiler, deps, sources, and artifact paths for one project.
+///
+/// Called once per project/member from [`collect_all`] (not recursive).
+fn collect_project_info_inner(
+    root: &Path,
+    profile: &str,
+    workspace_root: Option<&Path>,
+) -> Result<ProjectInfo, String> {
+    let root = canonicalize_path(root);
    let config = Config::open("./dcr.toml").map_err(|e| e.to_string())?;

    let name = get_config_str(&config, "package.name");
@@ -249,15 +295,32 @@ fn collect_project_info_inner(root: &Path, profile: &str) -> Result<ProjectInfo,
    let standard = get_string_with_profile(&config, "standard", profile);
    let cxx_standard = get_string_with_profile(&config, "cxx_standard", profile);
    let compiler_s = get_string_with_profile(&config, "compiler", profile);
-    let kind = get_string_with_profile(&config, "kind", profile);
+    let kind_raw = get_string_with_profile(&config, "kind", profile);
+    let kind = normalize_kind(&kind_raw).to_string();
    let build_target = get_string_with_profile(&config, "target", profile);
    let platform = get_string_with_profile(&config, "platform", profile);
+    let output_filename_s = get_string_with_profile(&config, "filename", profile);
+    let output_extension_s = get_string_with_profile(&config, "extension", profile);
+    let output_filename = if output_filename_s.is_empty() {
+        None
+    } else {
+        Some(output_filename_s)
+    };
+    let output_extension = if output_extension_s.is_empty() {
+        None
+    } else {
+        Some(output_extension_s)
+    };

    let tc_cc = get_config_opt(&config, "toolchain.cc");
    let tc_cxx = get_config_opt(&config, "toolchain.cxx");
    let tc_as = get_config_opt(&config, "toolchain.as");
    let tc_ar = get_config_opt(&config, "toolchain.ar");
    let tc_ld = get_config_opt(&config, "toolchain.ld");
+    let tc_moc = get_config_opt(&config, "toolchain.moc");
+    let tc_uic = get_config_opt(&config, "toolchain.uic");
+    let tc_rcc = get_config_opt(&config, "toolchain.rcc");
+    let tc_debugger = get_config_opt(&config, "toolchain.debugger");

    let base_cflags = get_list_with_profile(&config, "cflags", profile);
    let base_ldflags = get_list_with_profile(&config, "ldflags", profile);
@@ -286,7 +349,7 @@ fn collect_project_info_inner(root: &Path, profile: &str) -> Result<ProjectInfo,
            .filter(|v| !v.trim().is_empty())
    });

-    let resolved = resolve_deps_for_gen(&config, profile, root);
+    let resolved = resolve_deps_for_gen(&config, profile, &root);
    let (resolved_cflags, resolved_ldflags) =
        resolve_pkg_config_flags_lossy(&pkg_configs, &base_cflags, &base_ldflags);

@@ -352,7 +415,22 @@ fn collect_project_info_inner(root: &Path, profile: &str) -> Result<ProjectInfo,
        }
    }

-    let target_dir_binding = normalize_target(&build_target, profile);
+    let out_dir_config = get_string_with_profile(&config, "out_dir", profile);
+    let has_explicit = !build_target.trim().is_empty();
+    let target_dir_binding = resolve_artifact_target_dir(
+        &root,
+        workspace_root,
+        profile,
+        &build_target,
+        &out_dir_config,
+        has_explicit,
+    );
+    let target_dir_opt = if target_dir_binding.is_empty() {
+        None
+    } else {
+        Some(target_dir_binding.as_str())
+    };
+
    let ctx = BuildContext {
        profile,
        project_name: &name,
@@ -360,15 +438,19 @@ fn collect_project_info_inner(root: &Path, profile: &str) -> Result<ProjectInfo,
        language: &language,
        standard: &standard,
        cxx_standard: &cxx_standard,
-        target: Some(build_target.as_str()),
-        target_dir: target_dir_binding.as_deref(),
-        kind: normalize_kind(&kind),
+        target: if build_target.is_empty() {
+            None
+        } else {
+            Some(build_target.as_str())
+        },
+        target_dir: target_dir_opt,
+        kind: kind.as_str(),
        platform: normalize_platform(&platform),
        linker: resolved_linker.as_deref(),
        archiver: resolved_archiver.as_deref(),
-        moc: None,
-        uic: None,
-        rcc: None,
+        moc: tc_moc.as_deref(),
+        uic: tc_uic.as_deref(),
+        rcc: tc_rcc.as_deref(),
        package_type: None,
        freestanding: false,
        panic_abort: false,
@@ -381,8 +463,8 @@ fn collect_project_info_inner(root: &Path, profile: &str) -> Result<ProjectInfo,
        libs: &resolved.libs,
        cflags: &resolved_cflags,
        ldflags: &resolved_ldflags,
-        output_filename: None,
-        output_extension: None,
+        output_filename: output_filename.as_deref(),
+        output_extension: output_extension.as_deref(),
        verbose: false,
        qt: false,
    };
@@ -393,70 +475,342 @@ fn collect_project_info_inner(root: &Path, profile: &str) -> Result<ProjectInfo,
    let abs_sources: Vec<String> = sources
        .iter()
        .map(|s| {
-            let p = Path::new(s);
-            if p.is_absolute() {
-                s.clone()
-            } else {
-                root.join(s).to_string_lossy().to_string()
-            }
+            absolute_join(&root, Path::new(s))
+                .to_string_lossy()
+                .to_string()
        })
        .collect();

+    let abs_include_dirs: Vec<String> = merged_include_dirs
+        .iter()
+        .map(|d| {
+            absolute_join(&root, Path::new(d))
+                .to_string_lossy()
+                .to_string()
+        })
+        .collect();
+
+    let abs_lib_dirs: Vec<String> = resolved
+        .lib_dirs
+        .iter()
+        .map(|d| {
+            absolute_join(&root, Path::new(d))
+                .to_string_lossy()
+                .to_string()
+        })
+        .collect();
+
+    let abs_source_roots: Vec<String> = source_roots
+        .iter()
+        .map(|p| canonicalize_path(p).to_string_lossy().to_string())
+        .collect();
+
+    let abs_target_dir = {
+        let p = Path::new(&target_dir_binding);
+        let path = if p.is_absolute() {
+            canonicalize_path(p)
+        } else {
+            absolute_join(&root, p)
+        };
+        path.to_string_lossy().into_owned()
+    };
+
+    let relative_artifact = resolve_artifact_path(
+        &kind,
+        profile,
+        &name,
+        Some(&abs_target_dir),
+        output_filename.as_deref(),
+        output_extension.as_deref(),
+    );
+
+    let artifact_path = relative_artifact.map(|rel| {
+        absolute_artifact_path(&root, &rel)
+            .to_string_lossy()
+            .to_string()
+    });
+
+    let debugger = resolve_debugger(tc_debugger.as_deref());
+    let ws_root = workspace_root.map(canonicalize_path);
+
    Ok(ProjectInfo {
        name,
        version,
-        root: root.to_path_buf(),
+        root,
        profile: profile.to_string(),
        language,
        standard,
        cxx_standard,
        compiler: resolved_compiler,
-        kind: normalize_kind(&kind).to_string(),
+        kind: kind.clone(),
+        target: build_target,
+        target_dir: Some(abs_target_dir),
+        artifact_path,
+        artifact_kind: kind,
        sources: abs_sources,
-        include_dirs: merged_include_dirs,
-        lib_dirs: resolved.lib_dirs,
+        include_dirs: abs_include_dirs,
+        lib_dirs: abs_lib_dirs,
        libs: resolved.libs,
        cflags: resolved_cflags,
        ldflags: resolved_ldflags,
+        source_roots: abs_source_roots,
+        include_globs: build_includes,
+        exclude_globs: build_excludes,
+        output_filename,
+        output_extension,
+        out_dir: out_dir_config,
+        debugger,
+        moc: tc_moc.and_then(|v| resolve_tool_path(&v)),
+        uic: tc_uic.and_then(|v| resolve_tool_path(&v)),
+        rcc: tc_rcc.and_then(|v| resolve_tool_path(&v)),
+        workspace_root: ws_root,
    })
 }

-/// Collect info for root project + all workspace members.
+fn find_in_path(name: &str) -> Option<String> {
+    if name.contains('/') || name.contains('\\') {
+        let p = Path::new(name);
+        if p.exists() {
+            return Some(canonicalize_path(p).to_string_lossy().to_string());
+        }
+        return Some(name.to_string());
+    }
+    let path_var = std::env::var_os("PATH")?;
+    for dir in std::env::split_paths(&path_var) {
+        let candidate = dir.join(name);
+        if candidate.is_file() {
+            return Some(canonicalize_path(&candidate).to_string_lossy().to_string());
+        }
+        #[cfg(windows)]
+        {
+            let with_exe = dir.join(format!("{name}.exe"));
+            if with_exe.is_file() {
+                return Some(canonicalize_path(&with_exe).to_string_lossy().to_string());
+            }
+        }
+    }
+    None
+}
+
+/// Resolves a tool name (e.g. moc, uic, rcc) for generated metadata.
+///
+/// Prefers a PATH hit via [`find_in_path`]; otherwise returns the trimmed name
+/// as given (absolute or relative). Empty input yields `None`.
+fn resolve_tool_path(name: &str) -> Option<String> {
+    let t = name.trim();
+    if t.is_empty() {
+        return None;
+    }
+    find_in_path(t).or_else(|| Some(t.to_string()))
+}
+
+/// Picks a debugger name: configured value if set, else first of lldb/gdb on PATH,
+/// else `cppvsdbg` on Windows or `lldb` elsewhere (even if not on PATH).
+fn resolve_debugger(configured: Option<&str>) -> String {
+    if let Some(d) = configured {
+        let t = d.trim();
+        if !t.is_empty() {
+            return t.to_string();
+        }
+    }
+    for candidate in ["lldb", "gdb"] {
+        if find_in_path(candidate).is_some() {
+            return candidate.to_string();
+        }
+    }
+    if cfg!(windows) {
+        "cppvsdbg".to_string()
+    } else {
+        "lldb".to_string()
+    }
+}
+
+fn utc_now_iso() -> String {
+    let secs = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|d| d.as_secs())
+        .unwrap_or(0);
+    let days = secs / 86400;
+    let tod = secs % 86400;
+    let hour = tod / 3600;
+    let min = (tod % 3600) / 60;
+    let sec = tod % 60;
+    let (year, month, day) = civil_from_days(days as i64);
+    format!("{year:04}-{month:02}-{day:02}T{hour:02}:{min:02}:{sec:02}Z")
+}
+
+/// Converts days since the Unix epoch to `(year, month, day)` (proleptic Gregorian).
+fn civil_from_days(days: i64) -> (i32, u32, u32) {
+    let z = days + 719468;
+    let era = if z >= 0 { z } else { z - 146096 } / 146097;
+    let doe = (z - era * 146097) as u32;
+    let yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365;
+    let y = (yoe as i64) + era * 400;
+    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
+    let mp = (5 * doy + 2) / 153;
+    let d = doy - (153 * mp + 2) / 5 + 1;
+    let m = if mp < 10 { mp + 3 } else { mp - 9 };
+    let y = if m <= 2 { y + 1 } else { y };
+    (y as i32, m, d)
+}
+
+/// Writes `.dcr/build-info.json` and `.dcr/toolchain.json` from project metadata.
+///
+/// # Parameters
+/// - `root`: Project root (creates `.dcr/` if needed).
+/// - `info`: Collected project metadata (compiler, artifact, toolchain tools).
+///
+/// # Returns
+/// `Ok(())` on success, or an error string if directory/file writes fail.
+pub fn write_dcr_metadata(root: &Path, info: &ProjectInfo) -> Result<(), String> {
+    let dcr = ensure_dcr_dir(root).map_err(|e| format!("Failed to create .dcr/: {e}"))?;
+
+    let artifact_json = match &info.artifact_path {
+        Some(p) => json_str(p),
+        None => "null".to_string(),
+    };
+    let target_dir_json = match &info.target_dir {
+        Some(p) => json_str(p),
+        None => "null".to_string(),
+    };
+
+    let build_info = format!(
+        r#"{{
+  "schemaVersion": 1,
+  "generatedAt": {generated},
+  "profile": {profile},
+  "compiler": {compiler},
+  "target": {target},
+  "target_dir": {target_dir},
+  "artifact_path": {artifact},
+  "artifact_kind": {kind}
+}}
+"#,
+        generated = json_str(&utc_now_iso()),
+        profile = json_str(&info.profile),
+        compiler = json_str(&info.compiler),
+        target = json_str(&info.target),
+        target_dir = target_dir_json,
+        artifact = artifact_json,
+        kind = json_str(&info.artifact_kind),
+    );
+    atomic_write(&dcr.join("build-info.json"), build_info.as_bytes())
+        .map_err(|e| format!("Failed to write build-info.json: {e}"))?;
+
+    let compiler_path = find_in_path(&info.compiler).unwrap_or_else(|| info.compiler.clone());
+    let debugger_path = find_in_path(&info.debugger).unwrap_or_else(|| info.debugger.clone());
+
+    let mut toolchain = String::from("{\n");
+    toolchain.push_str("  \"schemaVersion\": 1,\n");
+    toolchain.push_str(&format!("  \"compiler\": {},\n", json_str(&info.compiler)));
+    toolchain.push_str(&format!(
+        "  \"compilerPath\": {},\n",
+        json_str(&compiler_path)
+    ));
+    toolchain.push_str(&format!("  \"debugger\": {},\n", json_str(&info.debugger)));
+    toolchain.push_str(&format!("  \"debuggerPath\": {}", json_str(&debugger_path)));
+    if let Some(ref m) = info.moc {
+        toolchain.push_str(",\n");
+        toolchain.push_str(&format!("  \"moc\": {}", json_str(m)));
+    }
+    if let Some(ref u) = info.uic {
+        toolchain.push_str(",\n");
+        toolchain.push_str(&format!("  \"uic\": {}", json_str(u)));
+    }
+    if let Some(ref r) = info.rcc {
+        toolchain.push_str(",\n");
+        toolchain.push_str(&format!("  \"rcc\": {}", json_str(r)));
+    }
+    toolchain.push_str("\n}\n");
+    atomic_write(&dcr.join("toolchain.json"), toolchain.as_bytes())
+        .map_err(|e| format!("Failed to write toolchain.json: {e}"))?;
+
+    Ok(())
+}
+
+fn ensure_clangd(root: &Path, quiet: bool) {
+    let path = root.join(".clangd");
+    let marker = "# managed by dcr gen";
+    let desired = format!("{marker}\nCompileFlags:\n  CompilationDatabase: .dcr\n");
+    if path.exists() {
+        match std::fs::read_to_string(&path) {
+            Ok(content)
+                if content.contains(marker) || content.contains("CompilationDatabase: .dcr") =>
+            {
+                return;
+            }
+            Ok(_) => {
+                if !quiet {
+                    eprintln!(
+                        "Warning: .clangd already exists and is not managed by dcr; \
+                         set CompilationDatabase to .dcr manually if needed"
+                    );
+                }
+                return;
+            }
+            Err(_) => return,
+        }
+    }
+    let _ = std::fs::write(&path, desired);
+}
+
+/// Collects [`ProjectInfo`] for the root package and workspace members (skips failed members).
 fn collect_all(root: &Path, profile: &str) -> Result<Vec<ProjectInfo>, String> {
-    // Check for workspace
+    let root = canonicalize_path(root);
    let config = {
        let prev = std::env::current_dir().map_err(|e| e.to_string())?;
-        std::env::set_current_dir(root).map_err(|e| e.to_string())?;
+        std::env::set_current_dir(&root).map_err(|e| e.to_string())?;
        let cfg = Config::open("./dcr.toml").map_err(|e| e.to_string());
        let _ = std::env::set_current_dir(prev);
        cfg?
    };

    let mut all = Vec::new();
+    let is_workspace = parse_workspace(&config, profile, None, &root)
+        .ok()
+        .flatten()
+        .is_some();
+    let ws_root = if is_workspace {
+        Some(root.as_path())
+    } else {
+        None
+    };

-    if let Ok(Some(ws)) = parse_workspace(&config, profile, None, root) {
+    if let Ok(Some(ws)) = parse_workspace(&config, profile, None, &root) {
        for member in &ws.members {
-            match collect_project_info(&member.path, profile) {
+            let member_path = canonicalize_path(&member.path);
+            match collect_project_info(&member_path, profile, ws_root) {
                Ok(info) => all.push(info),
                Err(e) => eprintln!(
                    "Warning: skipping workspace member {}: {e}",
-                    member.path.display()
+                    member_path.display()
                ),
            }
        }
    }

-    // Root project itself
-    let root_info = collect_project_info(root, profile)?;
-    all.push(root_info);
+    if !is_workspace || !config.is_workspace_only() {
+        match collect_project_info(&root, profile, ws_root) {
+            Ok(info) => all.push(info),
+            Err(e) if is_workspace => {
+                eprintln!("Warning: skipping workspace root package: {e}");
+            }
+            Err(e) => return Err(e),
+        }
+    }
+
+    if all.is_empty() {
+        return Err("No project members found".to_string());
+    }

    Ok(all)
 }

 // ── dcr gen project-info ─────────────────────────────────────────────────────

+/// `dcr gen project-info`: print project metadata JSON; writes `.dcr` meta from the last entry.
 fn gen_project_info(args: &[String]) -> i32 {
-    let (root, profile) = match parse_gen_args(args) {
+    let (root, profile, quiet) = match parse_gen_args(args) {
        Ok(v) => v,
        Err(code) => return code,
    };
@@ -469,6 +823,14 @@ fn gen_project_info(args: &[String]) -> i32 {
        }
    };

+    if let Some(info) = all.last()
+        && let Err(e) = write_dcr_metadata(&root, info)
+        && !quiet
+    {
+        eprintln!("Warning: {e}");
+    }
+    ensure_clangd(&root, quiet);
+
    print!("[");
    for (i, info) in all.iter().enumerate() {
        if i > 0 {
@@ -482,6 +844,7 @@ fn gen_project_info(args: &[String]) -> i32 {
    0
 }

+/// Pretty multi-line JSON object for one [`ProjectInfo`] (used inside a JSON array).
 fn project_info_to_json(info: &ProjectInfo) -> String {
    let mut out = String::new();
    out.push_str("  {\n");
@@ -509,6 +872,25 @@ fn project_info_to_json(info: &ProjectInfo) -> String {
        json_str(&info.compiler)
    ));
    out.push_str(&format!("    \"kind\": {},\n", json_str(&info.kind)));
+    out.push_str(&format!("    \"target\": {},\n", json_str(&info.target)));
+    out.push_str(&format!(
+        "    \"target_dir\": {},\n",
+        match &info.target_dir {
+            Some(p) => json_str(p),
+            None => "null".to_string(),
+        }
+    ));
+    out.push_str(&format!(
+        "    \"artifact_path\": {},\n",
+        match &info.artifact_path {
+            Some(p) => json_str(p),
+            None => "null".to_string(),
+        }
+    ));
+    out.push_str(&format!(
+        "    \"artifact_kind\": {},\n",
+        json_str(&info.artifact_kind)
+    ));
    out.push_str(&format!(
        "    \"sources\": {},\n",
        json_str_array(&info.sources)
@@ -527,17 +909,30 @@ fn project_info_to_json(info: &ProjectInfo) -> String {
        json_str_array(&info.cflags)
    ));
    out.push_str(&format!(
-        "    \"ldflags\": {}\n",
+        "    \"ldflags\": {},\n",
        json_str_array(&info.ldflags)
    ));
+    out.push_str(&format!(
+        "    \"source_roots\": {},\n",
+        json_str_array(&info.source_roots)
+    ));
+    out.push_str(&format!(
+        "    \"include_globs\": {},\n",
+        json_str_array(&info.include_globs)
+    ));
+    out.push_str(&format!(
+        "    \"exclude_globs\": {}\n",
+        json_str_array(&info.exclude_globs)
+    ));
    out.push_str("  }");
    out
 }

 // ── dcr gen compile-commands ─────────────────────────────────────────────────

+/// `dcr gen compile-commands`: write `.dcr/compile_commands.json`.
 fn gen_compile_commands(args: &[String]) -> i32 {
-    let (root, profile) = match parse_gen_args(args) {
+    let (root, profile, quiet) = match parse_gen_args(args) {
        Ok(v) => v,
        Err(code) => return code,
    };
@@ -550,16 +945,32 @@ fn gen_compile_commands(args: &[String]) -> i32 {
        }
    };

-    gen_compile_commands_inner(&root, &profile, &all)
+    gen_compile_commands_inner(&root, &profile, &all, quiet)
 }

-fn gen_compile_commands_inner(root: &Path, profile: &str, all: &[ProjectInfo]) -> i32 {
-    let entries = build_compile_commands(all, profile);
+/// Writes compile_commands.json, build metadata, and ensures `.clangd`.
+///
+/// Used by `compile-commands`, `vscode`, and `clion`.
+fn gen_compile_commands_inner(root: &Path, profile: &str, all: &[ProjectInfo], quiet: bool) -> i32 {
+    if let Err(e) = ensure_dcr_dir(root) {
+        error(&format!("Failed to create .dcr/: {e}"));
+        return 1;
+    }

-    let out_path = root.join("compile_commands.json");
-    match std::fs::write(&out_path, &entries) {
+    let entries = build_compile_commands(all, profile);
+    let out_path = root.join(".dcr").join("compile_commands.json");
+    match atomic_write(&out_path, entries.as_bytes()) {
        Ok(_) => {
-            println!("Generated {}", out_path.display());
+            if let Some(info) = all.last()
+                && let Err(e) = write_dcr_metadata(root, info)
+                && !quiet
+            {
+                eprintln!("Warning: {e}");
+            }
+            ensure_clangd(root, quiet);
+            if !quiet {
+                println!("Generated {}", out_path.display());
+            }
            0
        }
        Err(e) => {
@@ -569,6 +980,7 @@ fn gen_compile_commands_inner(root: &Path, profile: &str, all: &[ProjectInfo]) -
    }
 }

+/// Builds a clangd/cpptools `compile_commands.json` array (one entry per source file).
 fn build_compile_commands(projects: &[ProjectInfo], profile: &str) -> String {
    let mut out = String::from("[\n");
    let mut first = true;
@@ -599,6 +1011,8 @@ fn build_compile_commands(projects: &[ProjectInfo], profile: &str) -> String {
    out
 }

+/// Assembles one compiler argv: compiler, `-c`, optional `-x` asm, source/obj paths,
+/// `-fPIC`, `-std=`, profile defaults, cflags, and include paths.
 fn build_compile_command(info: &ProjectInfo, source: &str, profile: &str) -> Vec<String> {
    let mut cmd: Vec<String> = Vec::new();
    let compiler = if info.compiler.is_empty() {
@@ -615,16 +1029,21 @@ fn build_compile_command(info: &ProjectInfo, source: &str, profile: &str) -> Vec
        cmd.push(flag.to_string());
    }

-    cmd.push(source.to_string());
+    let abs_source = absolute_join(&info.root, Path::new(source));
+    cmd.push(abs_source.to_string_lossy().to_string());

    // Object path (for -o, approximate — not critical for IntelliSense)
-    let obj_dir = info.root.join("target").join(profile).join("obj");
+
+    let obj_base = info
+        .target_dir
+        .as_ref()
+        .map(PathBuf::from)
+        .unwrap_or_else(|| info.root.join("target").join(profile));
+    let obj_dir = obj_base.join("obj");
    let obj_path = {
        let p = Path::new(source);
        let rel = strip_src_prefix(p);
-        obj_dir
-            .join(rel)
-            .with_extension("o")
+        absolute_join(&info.root, &obj_dir.join(rel).with_extension("o"))
            .to_string_lossy()
            .to_string()
    };
@@ -649,7 +1068,7 @@ fn build_compile_command(info: &ProjectInfo, source: &str, profile: &str) -> Vec
        }
    }

-    // Default profile flags (mirrors unix_cc.rs defaults)
+    // Default profile flags (same idea as default_profile_flags)
    match profile {
        "release" => {
            cmd.push("-O3".to_string());
@@ -670,19 +1089,15 @@ fn build_compile_command(info: &ProjectInfo, source: &str, profile: &str) -> Vec
        // Expand relative -I paths to absolute so clangd/cpptools work
        // regardless of their working directory.
        if let Some(rel) = flag.strip_prefix("-I") {
-            let p = Path::new(rel);
-            let abs = if p.is_absolute() {
-                p.to_path_buf()
-            } else {
-                info.root.join(p)
-            };
+            let abs = absolute_join(&info.root, Path::new(rel));
            cmd.push(format!("-I{}", abs.to_string_lossy()));
        } else {
            cmd.push(flag.clone());
        }
    }
    for dir in &info.include_dirs {
-        cmd.push(format!("-I{dir}"));
+        let abs = absolute_join(&info.root, Path::new(dir));
+        cmd.push(format!("-I{}", abs.to_string_lossy()));
    }

    cmd
@@ -702,8 +1117,9 @@ fn strip_src_prefix(p: &Path) -> PathBuf {

 // ── dcr gen vscode ───────────────────────────────────────────────────────────

+/// `dcr gen vscode`: compile_commands plus `.vscode/` tasks, launch, settings, extensions.
 fn gen_vscode(args: &[String]) -> i32 {
-    let (root, profile) = match parse_gen_args(args) {
+    let (root, profile, quiet) = match parse_gen_args(args) {
        Ok(v) => v,
        Err(code) => return code,
    };
@@ -718,7 +1134,7 @@ fn gen_vscode(args: &[String]) -> i32 {
    };

    // 1. Generate compile_commands.json
-    let cc_code = gen_compile_commands_inner(&root, &profile, &all);
+    let cc_code = gen_compile_commands_inner(&root, &profile, &all, quiet);
    if cc_code != 0 {
        return cc_code;
    }
@@ -842,6 +1258,62 @@ fn gen_tasks_json() -> String {
    .to_string()
 }

+/// Absolute program path for a launch config; reuses `artifact_path` when profiles match,
+/// otherwise recomputes from kind/target/out_dir/filename.
+fn resolve_launch_program(info: &ProjectInfo, profile: &str) -> String {
+    if info.profile == profile
+        && let Some(ref p) = info.artifact_path
+    {
+        return p.clone();
+    }
+    let has_explicit = !info.target.trim().is_empty();
+    let target_dir = resolve_artifact_target_dir(
+        &info.root,
+        info.workspace_root.as_deref(),
+        profile,
+        &info.target,
+        &info.out_dir,
+        has_explicit,
+    );
+    let rel = resolve_artifact_path(
+        &info.kind,
+        profile,
+        &info.name,
+        Some(&target_dir),
+        info.output_filename.as_deref(),
+        info.output_extension.as_deref(),
+    );
+    match rel {
+        Some(r) => absolute_artifact_path(&info.root, &r)
+            .to_string_lossy()
+            .to_string(),
+        None => {
+            let name = if cfg!(windows) && !info.name.to_ascii_lowercase().ends_with(".exe") {
+                format!("{}.exe", info.name)
+            } else {
+                info.name.clone()
+            };
+            Path::new(&target_dir)
+                .join(name)
+                .to_string_lossy()
+                .into_owned()
+        }
+    }
+}
+
+/// VS Code debug type from debugger name: `cppdbg`, `cppvsdbg`, or `lldb`.
+fn debug_type_for(info: &ProjectInfo) -> &'static str {
+    let d = info.debugger.to_lowercase();
+    if d.contains("gdb") || d == "cppdbg" {
+        "cppdbg"
+    } else if cfg!(windows) && (d.contains("vs") || d == "cppvsdbg") {
+        "cppvsdbg"
+    } else {
+        "lldb"
+    }
+}
+
+/// `launch.json` content: one debug config per `bin` target for debug and release.
 fn gen_launch_json(projects: &[ProjectInfo], _root: &Path) -> String {
    let mut configs = Vec::new();

@@ -851,25 +1323,14 @@ fn gen_launch_json(projects: &[ProjectInfo], _root: &Path) -> String {
        }

        // binary expected at info.root/target/<profile>/<name> (account for member projects)
-        let debug_bin = info
-            .root
-            .join("target")
-            .join("debug")
-            .join(&info.name)
-            .to_string_lossy()
-            .to_string();
-        let release_bin = info
-            .root
-            .join("target")
-            .join("release")
-            .join(&info.name)
-            .to_string_lossy()
-            .to_string();
+        let debug_bin = resolve_launch_program(info, "debug");
+        let release_bin = resolve_launch_program(info, "release");
+        let dtype = debug_type_for(info);

        let debug_entry = format!(
            r#"    {{
      "name": {name},
-      "type": "lldb",
+      "type": {dtype},
      "request": "launch",
      "program": {prog},
      "args": [],
@@ -879,6 +1340,7 @@ fn gen_launch_json(projects: &[ProjectInfo], _root: &Path) -> String {
      "preLaunchTask": "dcr: build (debug)"
    }}"#,
            name = json_str(&format!("{} (debug)", info.name)),
+            dtype = json_str(dtype),
            prog = json_str(&debug_bin),
            cwd = json_str(&info.root.to_string_lossy()),
        );
@@ -886,7 +1348,7 @@ fn gen_launch_json(projects: &[ProjectInfo], _root: &Path) -> String {
        let release_entry = format!(
            r#"    {{
      "name": {name},
-      "type": "lldb",
+      "type": {dtype},
      "request": "launch",
      "program": {prog},
      "args": [],
@@ -896,6 +1358,7 @@ fn gen_launch_json(projects: &[ProjectInfo], _root: &Path) -> String {
      "preLaunchTask": "dcr: build (release)"
    }}"#,
            name = json_str(&format!("{} (release)", info.name)),
+            dtype = json_str(dtype),
            prog = json_str(&release_bin),
            cwd = json_str(&info.root.to_string_lossy()),
        );
@@ -925,7 +1388,7 @@ fn gen_launch_json(projects: &[ProjectInfo], _root: &Path) -> String {
 }

 fn gen_settings_json(root: &Path) -> String {
-    let cc_dir = root.to_string_lossy();
+    let cc_dir = root.join(".dcr").to_string_lossy().to_string();
    format!(
        r#"{{
  "clangd.arguments": [
@@ -944,8 +1407,9 @@ fn gen_settings_json(root: &Path) -> String {

 // ── dcr gen clion ─────────────────────────────────────────────────────────────

+/// `dcr gen clion`: compile_commands plus `.idea/` tools, targets, misc, run configs.
 fn gen_clion(args: &[String]) -> i32 {
-    let (root, profile) = match parse_gen_args(args) {
+    let (root, profile, quiet) = match parse_gen_args(args) {
        Ok(v) => v,
        Err(code) => return code,
    };
@@ -960,7 +1424,7 @@ fn gen_clion(args: &[String]) -> i32 {
    };

    // 1. compile_commands.json
-    let cc_code = gen_compile_commands_inner(&root, &profile, &all);
+    let cc_code = gen_compile_commands_inner(&root, &profile, &all, quiet);
    if cc_code != 0 {
        return cc_code;
    }
@@ -1140,7 +1604,7 @@ fn gen_clion_custom_targets() -> String {
 }

 fn gen_clion_misc_xml(root: &Path) -> String {
-    let cc_path = root.join("compile_commands.json");
+    let cc_path = root.join(".dcr").join("compile_commands.json");
    let cc = xml_escape(&cc_path.to_string_lossy());
    format!(
        r#"<?xml version="1.0" encoding="UTF-8"?>
@@ -1154,9 +1618,10 @@ fn gen_clion_misc_xml(root: &Path) -> String {
    )
 }

-fn gen_clion_run_config(info: &ProjectInfo, root: &Path, profile: &str) -> String {
-    let bin_path = root.join("target").join(profile).join(&info.name);
-    let bin = xml_escape(&bin_path.to_string_lossy());
+/// XML for one CLion run configuration under `.idea/runConfigurations/`.
+fn gen_clion_run_config(info: &ProjectInfo, _root: &Path, profile: &str) -> String {
+    let bin_path = resolve_launch_program(info, profile);
+    let bin = xml_escape(&bin_path);
    let target = if profile == "release" {
        "dcr: build (release)"
    } else {
@@ -1206,12 +1671,15 @@ fn xml_escape(s: &str) -> String {

 // ── helpers ───────────────────────────────────────────────────────────────────

-fn parse_gen_args(args: &[String]) -> Result<(PathBuf, String), i32> {
+/// Parses `--debug` / `--release` / `--quiet` and resolves the project root.
+fn parse_gen_args(args: &[String]) -> Result<(PathBuf, String, bool), i32> {
    let mut profile = "debug".to_string();
+    let mut quiet = false;
    for arg in args {
        match arg.as_str() {
            "--debug" => profile = "debug".to_string(),
            "--release" => profile = "release".to_string(),
+            "--quiet" | "-q" => quiet = true,
            _ => {}
        }
    }
@@ -1222,7 +1690,7 @@ fn parse_gen_args(args: &[String]) -> Result<(PathBuf, String), i32> {
    })?;

    let root = match find_project_root(&start) {
-        Ok(Some(r)) => r,
+        Ok(Some(r)) => canonicalize_path(&r),
        Ok(None) => {
            error("dcr.toml not found");
            return Err(1);
@@ -1233,7 +1701,7 @@ fn parse_gen_args(args: &[String]) -> Result<(PathBuf, String), i32> {
        }
    };

-    Ok((root, profile))
+    Ok((root, profile, quiet))
 }

 fn json_str(s: &str) -> String {
--- a/src/cli/help.rs
+++ b/src/cli/help.rs
@@ -17,6 +17,12 @@

 use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, printc};

+/// Displays the help information for the DCR CLI tool.
+///
+/// Prints usage, commands, flags, options, examples, and a tip.
+///
+/// # Returns
+/// Always `0`.
 pub fn help() -> i32 {
    println!("DCR (Dexoron Cargo Realization)");
    println!("C project manager inspired by Cargo.");
@@ -29,9 +35,12 @@ pub fn help() -> i32 {
    println!("    init              Initialize the current directory as a project");
    println!("    build [--profile] Build the project (default: --debug)");
    println!("    run [--profile]   Build and run the project (default: --debug)");
+    println!("    add <name> ...    Add a dependency to dcr.toml");
    println!("    tree              Display the dependency tree");
    println!("    test              Run project tests (alias: tests)");
    println!("    fmt               Format all C/C++ source files using clang-format");
+    println!("    lint              Run clang-tidy on C/C++ sources");
+    println!("    setup             Show configured package registries");
    println!("    clean             Remove the target directory");
    println!("    gen <subcommand>  Generate IDE integration files");
    printc("FLAGS:", BOLD_GREEN);
--- a/src/cli/init.rs
+++ b/src/cli/init.rs
@@ -25,6 +25,10 @@ use std::fs;
 use std::io::Write;
 use toml::Value;

+/// Initializes the current working directory as a new DCR project.
+///
+/// Verifies that the current directory is empty, sets up the project structure by creating
+/// `dcr.toml` and `src/main.c`, and configures version control (Git) integration if applicable.
 pub fn init(args: &[String]) -> i32 {
    if args.first().is_some_and(|a| a == "--help") {
        printc("USAGE:", BOLD_GREEN);
@@ -36,6 +40,7 @@ pub fn init(args: &[String]) -> i32 {
        return 0;
    }

+    // Parse options (--vcs) and collect positional arguments.
    let mut vcs_str = None;
    let mut clean_args = Vec::new();
    let mut iter = args.iter();
@@ -59,6 +64,7 @@ pub fn init(args: &[String]) -> i32 {
        return 1;
    }

+    // Resolve target project name from current directory name and enforce empty directory check.
    let items = check_dir(None).unwrap_or_default();
    let project_name = std::env::current_dir()
        .ok()
@@ -84,6 +90,7 @@ pub fn init(args: &[String]) -> i32 {
        .unwrap_or_else(|_| ".".to_string());
    println!("Initializing the project in {cwd}");

+    // Create and initialize default manifest (dcr.toml).
    let mut config = match Config::new("./dcr.toml") {
        Ok(cfg) => cfg,
        Err(_) => {
@@ -104,6 +111,7 @@ pub fn init(args: &[String]) -> i32 {
        colored("dcr.toml", BOLD_CYAN)
    );

+    // Create src directory and write template main.c file.
    if fs::create_dir("src").is_err() {
        error("Failed to create src/");
        return 1;
@@ -125,7 +133,7 @@ pub fn init(args: &[String]) -> i32 {
        colored("src/main.c", BOLD_CYAN)
    );

-    // settings VCS
+    // Resolve target VCS provider or detect existing repositories.
    let mut vcs_kind = VcsKind::Git;
    if let Some(ref vcs_val) = vcs_str {
        match VcsKind::parse(vcs_val) {
@@ -159,6 +167,10 @@ pub fn init(args: &[String]) -> i32 {
        }
    }

+    if let Err(e) = crate::utils::fs::ensure_gitignore_has_dcr(std::path::Path::new(".")) {
+        warn(&format!("Failed to update .gitignore: {e}"));
+    }
+
    println!(
        "Project `{}` successfully created\n",
        colored(project_name.as_str(), BOLD_GREEN)
--- a/src/cli/lint.rs
+++ b/src/cli/lint.rs
@@ -24,6 +24,9 @@ use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, BOLD_YELLOW, colored, printc};
 use std::path::{Path, PathBuf};
 use std::process::Command;

+/// Runs clang-tidy on all C/C++ source files.
+///
+/// Scans source roots (configurable via build.roots) and tests/ directory.
 pub fn lint(args: &[String]) -> i32 {
    if args.first().is_some_and(|a| a == "--help") {
        printc("USAGE:", BOLD_GREEN);
@@ -72,6 +75,7 @@ pub fn lint(args: &[String]) -> i32 {
    let build_roots = get_list_with_profile(&config, "roots", profile);
    let src_disable = get_bool_with_profile(&config, "src_disable", profile, false);

+    // Construct source roots from config
    let mut source_roots: Vec<String> = Vec::new();
    for raw in &build_roots {
        let p = Path::new(raw);
@@ -126,6 +130,7 @@ pub fn lint(args: &[String]) -> i32 {
    let mut total_issues = 0u32;
    let mut failed = 0u32;

+    // Execute clang-tidy for each file and count issues
    for file in &files {
        let mut cmd = Command::new("clang-tidy");
        if do_fix {
--- a/src/cli/mod.rs
+++ b/src/cli/mod.rs
@@ -15,6 +15,9 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.

+/// DCR CLI module.
+///
+/// This module declares submodules for all DCR commands.
 pub mod add;
 pub mod build;
 pub mod clean;
--- a/src/cli/new.rs
+++ b/src/cli/new.rs
@@ -25,6 +25,10 @@ use std::fs;
 use std::io::Write;
 use toml::Value;

+/// Executes the `dcr new` command to scaffold a new C/C++ project directory structure.
+///
+/// Handles command-line argument parsing, directory creation, default configuration generation (`dcr.toml`),
+/// template source file generation (`src/main.c`), and initial VCS setup.
 pub fn new(args: &[String]) -> i32 {
    if args.first().is_some_and(|a| a == "--help") {
        printc("USAGE:", BOLD_GREEN);
@@ -38,6 +42,7 @@ pub fn new(args: &[String]) -> i32 {

    let items = check_dir(None).unwrap_or_default();

+    // Parse CLI options (--vcs) while extracting positional arguments for the project name.
    let mut vcs_str = None;
    let mut clean_args = Vec::new();
    let mut iter = args.iter();
@@ -85,7 +90,7 @@ pub fn new(args: &[String]) -> i32 {
            "Directory `{}` already exists\n",
            colored(project_name, BOLD_CYAN)
        ));
-        printc("Подсказка:", BOLD_CYAN);
+        printc("Hint:", BOLD_CYAN);
        println!(
            "    Use `{}` to initialize an existing project\n    or specify a different project name",
            colored("dcr init", BOLD_CYAN)
@@ -103,6 +108,7 @@ pub fn new(args: &[String]) -> i32 {
        project_name
    );

+    // Initialize and write project configuration manifest (dcr.toml).
    let toml_path = format!("./{project_name}/dcr.toml");
    let mut config = match Config::new(&toml_path) {
        Ok(cfg) => cfg,
@@ -124,6 +130,7 @@ pub fn new(args: &[String]) -> i32 {
        colored("dcr.toml", BOLD_CYAN)
    );

+    // Generate src directory and populate initial main.c file.
    if fs::create_dir_all(format!("./{project_name}/src")).is_err() {
        error("Failed to create src/");
        return 1;
@@ -146,7 +153,7 @@ pub fn new(args: &[String]) -> i32 {
        colored("src/main.c", BOLD_CYAN)
    );

-    // settings VCS
+    // Resolve target VCS mode based on CLI flags or parent directory state.
    let mut vcs_kind = VcsKind::Git;
    if let Some(ref vcs_val) = vcs_str {
        match VcsKind::parse(vcs_val) {
@@ -180,6 +187,11 @@ pub fn new(args: &[String]) -> i32 {
        }
    }

+    let project_path = std::path::Path::new(project_name);
+    if let Err(e) = crate::utils::fs::ensure_gitignore_has_dcr(project_path) {
+        warn(&format!("Failed to update .gitignore: {e}"));
+    }
+
    println!(
        "Project `{}` successfully created\n",
        colored(project_name, BOLD_GREEN)
--- a/src/cli/run.rs
+++ b/src/cli/run.rs
@@ -19,9 +19,7 @@ use crate::cli::build::build;
 use crate::cli::flags::parse_build_run_flags;
 use crate::core::build_config::Config;
 use crate::core::runner::run_binary;
-use crate::utils::build::{
-    default_target_triple, normalize_target_os, parse_version_info, substitute_vars,
-};
+use crate::utils::build::{normalize_target_os, parse_version_info, substitute_vars};
 use crate::utils::fs::find_project_root;
 use crate::utils::fs::with_dir;
 use crate::utils::log::error;
@@ -29,6 +27,8 @@ use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, colored, printc};
 use std::path::Path;
 use std::process::Command;

+/// Retrieves the run command from the config, preferring target-specific,
+/// then profile-specific, then the base `run.cmd`.
 fn get_run_cmd(
    config: &Config,
    profile: &str,
@@ -57,16 +57,25 @@ fn get_run_cmd(
    }
 }

+/// Handles the `dcr run` subcommand: parses flags, finds the project root,
+/// builds if needed, and runs the resulting binary or configured command.
+///
+/// # Parameters
+/// - `args`: Tokens after `dcr run` (build flags; after `--` → binary args).
+///
+/// # Returns
+/// Process exit code from the built binary / `run.cmd`, or non-zero on build/setup failure.
 pub fn run(args: &[String]) -> i32 {
    if args.first().is_some_and(|a| a == "--help") {
        printc("USAGE:", BOLD_GREEN);
        printc(
-            "    dcr run [--debug | --release] [--target <triple>] [--force] [--clean] [--verbose]",
+            "    dcr run [--debug | --release] [--target <triple>] [--force] [--clean] [--verbose] [-- <args>...]",
            BOLD_CYAN,
        );
        println!();
        printc("DESCRIPTION:", BOLD_GREEN);
        println!("    Builds and runs the project. Only available for kind = \"bin\".");
+        println!("    Arguments after `--` are passed to the built binary (cargo-style).");
        println!();
        printc("OPTIONS:", BOLD_GREEN);
        println!("    --debug              Run with debug profile (default)");
@@ -75,6 +84,7 @@ pub fn run(args: &[String]) -> i32 {
        println!("    --force              Force a full rebuild");
        println!("    --clean              Clean before building");
        println!("    --verbose            Print detailed build output");
+        println!("    -- <args>...         Arguments forwarded to the binary");
        return 0;
    }

@@ -110,8 +120,21 @@ pub fn run(args: &[String]) -> i32 {
        Err(_) => return 1,
    };

-    // Handle workspace-only root: delegate to workspace member
    if config.is_workspace_only() {
+        if let Some(cmd) = get_run_cmd(&config, &flags.profile, flags.target.as_deref(), "") {
+            let build_status = build(&args_for_build(&flags));
+            if build_status == 0 {
+                let display = display_run_cmd(&cmd, &flags.bin_args);
+                println!(
+                    "  {} {}",
+                    colored(&format!("{:<9}", "run"), BOLD_GREEN),
+                    display
+                );
+                return run_shell_with_args(&cmd, &flags.bin_args);
+            }
+            return build_status;
+        }
+
        let ws = match crate::core::workspace::parse_workspace(
            &config,
            &flags.profile,
@@ -164,6 +187,7 @@ pub fn run(args: &[String]) -> i32 {
    }
 }

+/// Builds and runs a single project at `root` (optionally as a workspace member).
 fn run_project(
    root: &Path,
    flags: &crate::cli::flags::BuildRunFlags,
@@ -177,10 +201,13 @@ fn run_project(
        .and_then(|v| v.as_str())
        .unwrap_or("");

-    // If no target specified, use default host target for target-specific config
    let mut target = flags.target.clone();
    if target.is_none() {
-        target = Some(default_target_triple());
+        let bt =
+            crate::cli::build::get_build_string_with_profile(&config, "target", &flags.profile);
+        if !bt.is_empty() {
+            target = Some(bt);
+        }
    }

    let build_kind = config
@@ -191,19 +218,17 @@ fn run_project(

    let out_dir =
        crate::cli::build::get_build_string_with_profile(&config, "out_dir", &flags.profile);
-    let normalized_target_dir = if !out_dir.is_empty() {
-        Some(out_dir)
-    } else {
-        match workspace_root {
-            Some(wr) => target
-                .as_ref()
-                .and_then(|t| crate::utils::build::normalize_target(t, &flags.profile))
-                .map(|rel| wr.join(&rel).to_string_lossy().to_string()),
-            None => target
-                .as_ref()
-                .and_then(|t| crate::utils::build::normalize_target(t, &flags.profile)),
-        }
-    };
+    let build_target_str = target.clone().unwrap_or_default();
+    let has_explicit = target.as_ref().is_some_and(|t| !t.trim().is_empty());
+
+    let normalized_target_dir = Some(crate::utils::build::resolve_artifact_target_dir(
+        root,
+        workspace_root,
+        &flags.profile,
+        &build_target_str,
+        &out_dir,
+        has_explicit,
+    ));

    let version = config
        .get("package.version")
@@ -213,7 +238,11 @@ fn run_project(

    let kind = build_kind.trim();
    if run_cmd.is_none()
-        && (kind == "staticlib" || kind == "sharedlib" || kind == "efi" || kind == "elf")
+        && (kind == "staticlib"
+            || kind == "sharedlib"
+            || kind == "efi"
+            || kind == "elf"
+            || kind == "flat-bin")
    {
        return Err("Cannot run library build".to_string());
    }
@@ -233,26 +262,36 @@ fn run_project(
    );
    if build_status == 0 {
        if let Some(cmd) = run_cmd {
-            println!("\n    {} {}", colored("Running", BOLD_GREEN), cmd);
-            println!("--------------------------------");
-            return Ok(run_shell(&cmd));
+            let display = display_run_cmd(&cmd, &flags.bin_args);
+            println!(
+                "  {} {}",
+                colored(&format!("{:<9}", "run"), BOLD_GREEN),
+                display
+            );
+            return Ok(run_shell_with_args(&cmd, &flags.bin_args));
        }
-        println!("\n    {} {}", colored("Running", BOLD_GREEN), bin_path);
-        println!("--------------------------------");
+        let display = display_bin_run(&bin_path, &flags.bin_args);
+        println!(
+            "  {} {}",
+            colored(&format!("{:<9}", "run"), BOLD_GREEN),
+            display
+        );
        return Ok(run_binary(
            project_name,
            &flags.profile,
            normalized_target_dir.as_deref(),
+            &flags.bin_args,
        ));
    }

    let fallback_code = if let Some(cmd) = run_cmd {
-        run_shell(&cmd)
+        run_shell_with_args(&cmd, &flags.bin_args)
    } else {
        run_binary(
            project_name,
            &flags.profile,
            normalized_target_dir.as_deref(),
+            &flags.bin_args,
        )
    };
    if fallback_code != 1 {
@@ -262,6 +301,7 @@ fn run_project(
    Err("Fix errors in the code to run the project".to_string())
 }

+/// Builds the list of arguments for the build command based on the provided flags.
 fn args_for_build(flags: &crate::cli::flags::BuildRunFlags) -> Vec<String> {
    let mut args = Vec::new();
    args.push(format!("--{}", flags.profile));
@@ -285,6 +325,7 @@ fn args_for_build(flags: &crate::cli::flags::BuildRunFlags) -> Vec<String> {
    args
 }

+/// Constructs build arguments specifically for a workspace member.
 fn args_for_workspace_build(
    flags: &crate::cli::flags::BuildRunFlags,
    member_name: &str,
@@ -309,6 +350,7 @@ fn args_for_workspace_build(
    args
 }

+/// Executes the given shell command and returns its exit code.
 fn run_shell(cmd: &str) -> i32 {
    let status = if cfg!(target_os = "windows") {
        Command::new("cmd").arg("/C").arg(cmd).status()
@@ -322,6 +364,67 @@ fn run_shell(cmd: &str) -> i32 {
    }
 }

+/// Runs the command, appending escaped binary arguments if provided.
+fn run_shell_with_args(cmd: &str, bin_args: &[String]) -> i32 {
+    if bin_args.is_empty() {
+        return run_shell(cmd);
+    }
+    let mut full = cmd.to_string();
+    for arg in bin_args {
+        full.push(' ');
+        full.push_str(&shell_escape(arg));
+    }
+    run_shell(&full)
+}
+
+/// Formats the run command string for console output, appending arguments if any.
+fn display_run_cmd(cmd: &str, bin_args: &[String]) -> String {
+    if bin_args.is_empty() {
+        return cmd.to_string();
+    }
+    let mut display = cmd.to_string();
+    for arg in bin_args {
+        display.push(' ');
+        display.push_str(arg);
+    }
+    display
+}
+
+/// Formats the binary path for console display, appending arguments if any.
+fn display_bin_run(bin_path: &str, bin_args: &[String]) -> String {
+    if bin_args.is_empty() {
+        return bin_path.to_string();
+    }
+    let mut display = bin_path.to_string();
+    for arg in bin_args {
+        display.push(' ');
+        display.push_str(arg);
+    }
+    display
+}
+
+/// Escapes the argument for safe shell execution, using double quotes on Windows and single quotes on Unix.
+fn shell_escape(arg: &str) -> String {
+    if cfg!(target_os = "windows") {
+        // cmd.exe: wrap in double quotes and escape embedded quotes.
+        let escaped = arg.replace('"', "\\\"");
+        format!("\"{escaped}\"")
+    } else {
+        // POSIX sh: single-quote and escape embedded single quotes as '\''.
+        let mut out = String::from("'");
+        for ch in arg.chars() {
+            if ch == '\'' {
+                out.push_str("'\\''");
+            } else {
+                out.push(ch);
+            }
+        }
+        out.push('\'');
+        out
+    }
+}
+
+/// Replaces version info and profile in the command template.
 fn substitute_run_vars(cmd: &str, profile: &str, version: &str) -> String {
    let info = parse_version_info(version);
    substitute_vars(cmd, &info, profile, "")
--- a/src/cli/setup.rs
+++ b/src/cli/setup.rs
@@ -17,6 +17,7 @@

 use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, printc};

+/// Sets up DCR registries by loading the registry manager and printing the list of registries.
 pub fn setup(args: &[String]) -> i32 {
    if args.first().is_some_and(|a| a == "--help") {
        printc("USAGE:", BOLD_GREEN);
@@ -29,6 +30,7 @@ pub fn setup(args: &[String]) -> i32 {
    }

    println!("Setting up DCR registries...");
+    // Load and process the registries, returning 0 on success or 1 on error
    match crate::core::registry::RegistryManager::load() {
        Ok(manager) => {
            println!("Loaded {} registries.", manager.config.registry.len());
--- a/src/cli/test.rs
+++ b/src/cli/test.rs
@@ -31,6 +31,7 @@ use std::process::Command;

 const BOLD_BLUE: &str = "\x1b[1m\x1b[94m";

+/// Runs project tests and prints a unified testsuite report.
 pub fn test(args: &[String]) -> i32 {
    let mut init_header = false;
    let mut profile = "debug";
@@ -101,6 +102,7 @@ pub fn test(args: &[String]) -> i32 {
    }
 }

+/// Executes the testsuite for the given build profile.
 fn run_testsuite(profile: &str) -> Result<i32, String> {
    if build::build(&[format!("--{profile}")]) != 0 {
        return Ok(1);
@@ -260,6 +262,7 @@ fn run_testsuite(profile: &str) -> Result<i32, String> {
    Ok(0)
 }

+/// Collects all .c source files from the tests/ directory.
 fn collect_test_sources() -> Result<Vec<PathBuf>, String> {
    let tests_dir = Path::new("./tests");
    if !tests_dir.is_dir() {
@@ -278,6 +281,7 @@ fn collect_test_sources() -> Result<Vec<PathBuf>, String> {
    Ok(sources)
 }

+/// Returns a list of include directories for test compilation.
 fn test_include_dirs(config: &Config, profile: &str) -> Vec<String> {
    let mut dirs = vec![
        "./tests".to_string(),
@@ -288,6 +292,7 @@ fn test_include_dirs(config: &Config, profile: &str) -> Vec<String> {
    dirs
 }

+/// Compiles a single test source file to an object file.
 fn compile_test_source(
    compiler: &str,
    standard: &str,
@@ -317,6 +322,7 @@ fn compile_test_source(
    Ok(())
 }

+/// Links the test object file into an executable binary.
 fn link_test_binary(
    compiler: &str,
    ldflags: &[String],
@@ -343,6 +349,7 @@ fn link_test_binary(
    Ok(())
 }

+/// Prints the stdout and stderr from a command execution.
 fn print_command_output(output: &std::process::Output) {
    if !output.stdout.is_empty() {
        print!("{}", String::from_utf8_lossy(&output.stdout));
@@ -352,6 +359,7 @@ fn print_command_output(output: &std::process::Output) {
    }
 }

+/// Creates the default test files (dcr_test.h and test.c) in the tests/ directory.
 fn ensure_test_header() -> Result<(), String> {
    fs::create_dir_all("./tests").map_err(|_| "Failed to create tests/".to_string())?;
    fs::write("./tests/dcr_test.h", FILE_DCR_TEST_H)
@@ -363,6 +371,7 @@ fn ensure_test_header() -> Result<(), String> {
    Ok(())
 }

+/// Extracts test case names from a C source file by parsing TEST_CASE macros.
 fn extract_test_names_path(path: &Path) -> Vec<String> {
    let Ok(content) = fs::read_to_string(path) else {
        return Vec::new();
@@ -379,6 +388,7 @@ fn extract_test_names_path(path: &Path) -> Vec<String> {
    names
 }

+/// Prints a test result field with color coding.
 fn print_field(label: &str, value: i32, color: &str) {
    if value == 0 {
        println!("{}:  {}", label, value);
--- a/src/cli/tree.rs
+++ b/src/cli/tree.rs
@@ -22,6 +22,10 @@ use std::collections::HashSet;
 use std::path::{Path, PathBuf};
 use toml::Value;

+/// Displays the dependency tree of the current project.
+///
+/// This function checks for the --help flag and prints usage information if present.
+/// Otherwise, it parses the dcr.toml configuration and prints the dependency tree.
 pub fn tree(args: &[String]) -> i32 {
    if args.first().is_some_and(|a| a == "--help") {
        printc("USAGE:", BOLD_GREEN);
@@ -62,6 +66,9 @@ pub fn tree(args: &[String]) -> i32 {
    0
 }

+/// Recursively prints the dependency tree starting from the given dependencies table.
+///
+/// Sorts dependencies for consistent ordering and handles path resolution for sub-dependencies.
 fn print_deps(
    deps: &toml::value::Table,
    base_path: &Path,
@@ -81,6 +88,7 @@ fn print_deps(
        let mut sub_deps = None;
        let mut resolved_path = None;

+        // Resolve dependency path if it's a path-based dependency
        if let Some(path) = &dep_path {
            let dcr_toml = path.join("dcr.toml");
            if dcr_toml.exists()
@@ -117,6 +125,7 @@ fn print_deps(

        println!("{}{}{}{}", prefix, connector, name, version);

+        // Recurse only if sub-dependencies exist and this dep hasn't been seen
        if let Some(s_deps) = sub_deps
            && !seen.contains(*name)
        {
@@ -130,6 +139,7 @@ fn print_deps(
    }
 }

+/// Resolves the filesystem path for a dependency entry if it specifies a "path:" prefix or table with "path" key.
 fn resolve_dep_path(value: &Value, base_path: &Path) -> Option<PathBuf> {
    match value {
        Value::String(s) => s
--- a/src/config.rs
+++ b/src/config.rs
@@ -96,6 +96,7 @@ int main(int argc, char **argv) {
 }
 "#;

+/// Returns build flags for the given profile as a static slice, or None if empty.
 pub fn flags(profile: &str) -> Option<&'static [&'static str]> {
    let f = crate::utils::build::default_profile_flags(profile);
    if f.is_empty() { None } else { Some(f) }
--- a/src/core/build/archive.rs
+++ b/src/core/build/archive.rs
@@ -0,0 +1,276 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use crate::core::build_config::ArchiveConfig;
+use fatfs::{FileSystem, FormatVolumeOptions, format_volume};
+use glob::glob;
+use std::fs::{self, File, OpenOptions};
+use std::io::{self, Read, Seek, SeekFrom, Write};
+use std::path::Path;
+
+/// File wrapper that shifts all seek offsets (used to skip the boot sector on a FAT image).
+struct OffsetFile<T> {
+    inner: T,
+    offset: u64,
+}
+
+impl<T: Read> Read for OffsetFile<T> {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        self.inner.read(buf)
+    }
+}
+
+impl<T: Write> Write for OffsetFile<T> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.inner.write(buf)
+    }
+    fn flush(&mut self) -> io::Result<()> {
+        self.inner.flush()
+    }
+}
+
+impl<T: Seek> Seek for OffsetFile<T> {
+    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
+        match pos {
+            SeekFrom::Start(n) => {
+                let actual = self.inner.seek(SeekFrom::Start(n + self.offset))?;
+                if actual < self.offset {
+                    Ok(0)
+                } else {
+                    Ok(actual - self.offset)
+                }
+            }
+            SeekFrom::Current(n) => {
+                let actual = self.inner.seek(SeekFrom::Current(n))?;
+                if actual < self.offset {
+                    Ok(0)
+                } else {
+                    Ok(actual - self.offset)
+                }
+            }
+            SeekFrom::End(n) => {
+                let actual = self.inner.seek(SeekFrom::End(n))?;
+                if actual < self.offset {
+                    Ok(0)
+                } else {
+                    Ok(actual - self.offset)
+                }
+            }
+        }
+    }
+}
+
+/// Parses a size string like `1.5m` or `500k` into bytes (1024-based; empty → 0).
+fn parse_size(s: &str) -> Result<u64, String> {
+    let s = s.trim();
+    if s.is_empty() {
+        return Ok(0);
+    }
+    let mut num_str = String::new();
+    let mut unit = String::new();
+    for c in s.chars() {
+        if c.is_ascii_digit() || c == '.' {
+            num_str.push(c);
+        } else {
+            unit.push(c);
+        }
+    }
+    let val: f64 = num_str
+        .parse()
+        .map_err(|_| format!("invalid size number: {num_str}"))?;
+    let unit = unit.trim().to_lowercase();
+    let multiplier = match unit.as_str() {
+        "k" | "kb" => 1024.0,
+        "m" | "mb" => 1024.0 * 1024.0,
+        "g" | "gb" => 1024.0 * 1024.0 * 1024.0,
+        "" => 1.0,
+        _ => return Err(format!("unknown unit: {unit}")),
+    };
+    Ok((val * multiplier) as u64)
+}
+
+/// Creates a FAT image from layout config, substituting `{profile}` and optional boot sector.
+pub fn pack_archive(
+    project_root: &Path,
+    config: &ArchiveConfig,
+    profile: &str,
+) -> Result<(), String> {
+    let output_substituted = config.output.replace("{profile}", profile);
+    let output_path = project_root.join(&output_substituted);
+    if let Some(parent) = output_path.parent() {
+        fs::create_dir_all(parent)
+            .map_err(|e| format!("failed to create output parent dir: {e}"))?;
+    }
+
+    let size = if let Some(sz_str) = &config.size {
+        parse_size(sz_str)?
+    } else {
+        1474560
+    };
+
+    let offset = if let Some(off_str) = &config.offset {
+        parse_size(off_str)?
+    } else {
+        0
+    };
+
+    let mut file = OpenOptions::new()
+        .read(true)
+        .write(true)
+        .create(true)
+        .truncate(false)
+        .open(&output_path)
+        .map_err(|e| format!("failed to open output file: {e}"))?;
+
+    let current_len = file.metadata().map(|m| m.len()).unwrap_or(0);
+    if current_len < size {
+        file.set_len(size)
+            .map_err(|e| format!("failed to set image file size: {e}"))?;
+    }
+
+    if offset == 0
+        && let Some(boot_rel) = &config.bootsector
+    {
+        // Load and write bootsector if present
+        let boot_rel_substituted = boot_rel.replace("{profile}", profile);
+        let boot_path = project_root.join(&boot_rel_substituted);
+        if boot_path.is_file() {
+            let mut boot_file =
+                File::open(&boot_path).map_err(|e| format!("failed to open bootsector: {e}"))?;
+            let mut boot_bytes = vec![0; 512];
+            let _ = boot_file
+                .read(&mut boot_bytes)
+                .map_err(|e| format!("failed to read bootsector: {e}"))?;
+            file.seek(SeekFrom::Start(0))
+                .map_err(|e| format!("failed to seek to start: {e}"))?;
+            file.write_all(&boot_bytes)
+                .map_err(|e| format!("failed to write bootsector: {e}"))?;
+        }
+    }
+
+    file.seek(SeekFrom::Start(0))
+        .map_err(|e| format!("failed to seek to start: {e}"))?;
+
+    let mut wrapper = OffsetFile {
+        inner: file,
+        offset,
+    };
+
+    let label = config.label.as_deref().unwrap_or("VOLUME");
+    let mut label_bytes = [b' '; 11];
+    let bytes_to_copy = label.len().min(11);
+    label_bytes[..bytes_to_copy].copy_from_slice(&label.as_bytes()[..bytes_to_copy]);
+
+    let fat_type = match config.format.to_lowercase().as_str() {
+        "fat12" => Some(fatfs::FatType::Fat12),
+        "fat16" => Some(fatfs::FatType::Fat16),
+        "fat32" => Some(fatfs::FatType::Fat32),
+        _ => None,
+    };
+
+    let mut options = FormatVolumeOptions::new().volume_label(label_bytes);
+    if let Some(t) = fat_type {
+        options = options.fat_type(t);
+    }
+
+    format_volume(&mut wrapper, options)
+        .map_err(|e| format!("failed to format FAT volume: {e}"))?;
+
+    wrapper
+        .seek(SeekFrom::Start(0))
+        .map_err(|e| format!("failed to seek to start after format: {e}"))?;
+
+    let fs = FileSystem::new(wrapper, fatfs::FsOptions::new())
+        .map_err(|e| format!("failed to mount FAT fs: {e}"))?;
+    let root_dir = fs.root_dir();
+
+    for layout in &config.layout {
+        let from_substituted = layout.from.replace("{profile}", profile);
+        let from_pattern = project_root
+            .join(&from_substituted)
+            .to_string_lossy()
+            .to_string();
+
+        let paths = if from_pattern.contains('*') || from_pattern.contains('?') {
+            let mut matched = Vec::new();
+            if let Ok(entries) = glob(&from_pattern) {
+                for path in entries.flatten() {
+                    matched.push(path);
+                }
+            }
+            matched
+        } else {
+            let p = project_root.join(&from_substituted);
+            if p.exists() { vec![p] } else { Vec::new() }
+        };
+
+        for path in paths {
+            if !path.is_file() {
+                continue;
+            }
+            let filename = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
+            if filename.is_empty() {
+                continue;
+            }
+
+            let mut target_filename = filename.to_string();
+            let mut target_dir_str = layout.to.trim_matches('/');
+
+            let is_glob = from_pattern.contains('*') || from_pattern.contains('?');
+            if !is_glob
+                && !layout.to.ends_with('/')
+                && let Some(last_part) = Path::new(&layout.to).file_name().and_then(|n| n.to_str())
+                && last_part.contains('.')
+            {
+                target_filename = last_part.to_string();
+                let parent_path = Path::new(&layout.to).parent().unwrap_or(Path::new(""));
+                target_dir_str = parent_path.to_str().unwrap_or("").trim_matches('/');
+            }
+
+            let mut current_dir = root_dir.clone();
+            if !target_dir_str.is_empty() {
+                let parts = target_dir_str.split('/');
+                for part in parts {
+                    if part.is_empty() {
+                        continue;
+                    }
+                    current_dir = match current_dir.open_dir(part) {
+                        Ok(dir) => dir,
+                        Err(_) => current_dir
+                            .create_dir(part)
+                            .map_err(|e| format!("failed to create dir {part}: {e}"))?,
+                    };
+                }
+            }
+
+            let mut out_file = current_dir
+                .create_file(&target_filename)
+                .map_err(|e| format!("failed to create file {target_filename}: {e}"))?;
+            let mut in_file =
+                File::open(&path).map_err(|e| format!("failed to open input file: {e}"))?;
+            let mut buffer = Vec::new();
+            in_file
+                .read_to_end(&mut buffer)
+                .map_err(|e| format!("failed to read input file: {e}"))?;
+            out_file
+                .write_all(&buffer)
+                .map_err(|e| format!("failed to write to FAT file {target_filename}: {e}"))?;
+        }
+    }
+
+    Ok(())
+}
--- a/src/core/build/builder/artifact.rs
+++ b/src/core/build/builder/artifact.rs
@@ -19,9 +19,214 @@ use crate::core::build::builder::BuildContext;
 use crate::core::build::common;
 use crate::platform;
 use crate::utils::build::is_bare_metal_target;
+use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::time::Instant;

+/// Returns the artifact directory path based on the build context.
+pub(crate) fn artifact_dir(ctx: &BuildContext) -> PathBuf {
+    match ctx.target_dir {
+        Some(dir) => Path::new(dir).to_path_buf(),
+        None => Path::new("./target").join(ctx.profile),
+    }
+}
+
+/// Resolves the artifact path for a given kind/profile/name.
+///
+/// # Parameters
+/// - `kind`: Artifact kind (`bin`, `staticlib`, `sharedlib`, `flat-bin`, `efi`, `elf`, …).
+/// - `profile`: Build profile (`debug` / `release` / custom).
+/// - `project_name`: Default basename when `output_filename` is unset.
+/// - `target_dir`: Optional artifact directory override.
+/// - `output_filename` / `output_extension`: Optional name/ext overrides.
+///
+/// # Returns
+/// Relative/absolute path string, or `None` for `none` / `custom` kinds.
+pub fn resolve_artifact_path(
+    kind: &str,
+    profile: &str,
+    project_name: &str,
+    target_dir: Option<&str>,
+    output_filename: Option<&str>,
+    output_extension: Option<&str>,
+) -> Option<String> {
+    if crate::utils::build::is_flat_bin(kind) {
+        let name = output_filename.unwrap_or(project_name);
+        let ext = output_extension.unwrap_or("bin");
+        let file = if ext.is_empty() {
+            name.to_string()
+        } else {
+            format!("{name}.{ext}")
+        };
+        let dir = match target_dir {
+            Some(dir) => Path::new(dir).to_path_buf(),
+            None => Path::new("./target").join(profile),
+        };
+        return Some(dir.join(file).to_string_lossy().to_string());
+    }
+
+    if matches!(kind, "none" | "custom") {
+        return None;
+    }
+
+    let name = output_filename.unwrap_or(project_name);
+    let ext = output_extension.unwrap_or("");
+    let final_name = if ext.is_empty() {
+        name.to_string()
+    } else {
+        format!("{}.{}", name, ext)
+    };
+
+    let path = match kind {
+        "staticlib" => platform::lib_path(profile, &final_name, target_dir),
+        "sharedlib" => platform::shared_lib_path(profile, &final_name, target_dir),
+        "efi" => platform::efi_path(profile, &final_name, target_dir),
+        "elf" => platform::elf_path(profile, &final_name, target_dir),
+        _ => platform::bin_path(profile, &final_name, target_dir),
+    };
+    Some(path)
+}
+
+/// Converts a relative or absolute path to an absolute path by joining with project root if needed.
+pub fn absolute_artifact_path(project_root: &Path, relative_or_abs: &str) -> PathBuf {
+    let p = Path::new(relative_or_abs);
+    let joined = if p.is_absolute() {
+        p.to_path_buf()
+    } else {
+        let stripped = relative_or_abs
+            .strip_prefix("./")
+            .unwrap_or(relative_or_abs);
+        project_root.join(stripped)
+    };
+    crate::utils::fs::canonicalize_path(&joined)
+}
+
+/// Returns the output path for a flat binary artifact.
+pub(crate) fn flat_output_path(ctx: &BuildContext) -> String {
+    let name = ctx.output_filename.unwrap_or(ctx.project_name);
+    let ext = ctx.output_extension.unwrap_or("bin");
+    let file = if ext.is_empty() {
+        name.to_string()
+    } else {
+        format!("{name}.{ext}")
+    };
+    artifact_dir(ctx).join(file).to_string_lossy().to_string()
+}
+
+/// Returns the output path for a flat binary artifact from a source file.
+pub(crate) fn flat_source_output_path(ctx: &BuildContext, source: &str) -> String {
+    let stem = Path::new(source)
+        .file_stem()
+        .and_then(|s| s.to_str())
+        .unwrap_or("out");
+    let ext = ctx.output_extension.unwrap_or("bin");
+    let file = if ext.is_empty() {
+        stem.to_string()
+    } else {
+        format!("{stem}.{ext}")
+    };
+    artifact_dir(ctx).join(file).to_string_lossy().to_string()
+}
+
+// Helper to find a suitable objcopy tool in PATH
+fn resolve_objcopy() -> Result<String, String> {
+    for candidate in ["llvm-objcopy", "objcopy", "gobjcopy"] {
+        if Command::new(candidate)
+            .arg("--version")
+            .output()
+            .map(|o| o.status.success())
+            .unwrap_or(false)
+        {
+            return Ok(candidate.to_string());
+        }
+    }
+    Err(
+        "flat-bin requires llvm-objcopy, objcopy, or gobjcopy in PATH \
+         (install binutils or LLVM tools)"
+            .to_string(),
+    )
+}
+
+/// Converts an object/ELF to a raw binary via `objcopy -O binary` (skips if up to date).
+pub(crate) fn objcopy_binary(ctx: &BuildContext, input: &str, output: &str) -> Result<(), String> {
+    if let Some(parent) = Path::new(output).parent() {
+        std::fs::create_dir_all(parent).map_err(|e| format!("output dir error: {e}"))?;
+    }
+    if !common::needs_rebuild(input, output) {
+        return Ok(());
+    }
+    let tool = resolve_objcopy()?;
+    let mut cmd = Command::new(&tool);
+    cmd.arg("-O").arg("binary").arg(input).arg(output);
+    if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
+        eprintln!("[dcr] {:?}", cmd);
+    }
+    common::run_command_sync_output(&mut cmd)
+}
+
+/// Links objects into an intermediate ELF, then converts it to a flat binary via objcopy.
+pub(crate) fn link_flat_binary(
+    ctx: &BuildContext,
+    objects: &[String],
+    default_linker: &str,
+    start_time: Instant,
+) -> Result<f64, String> {
+    let out_path = flat_output_path(ctx);
+    if !common::needs_link(objects, &out_path) {
+        return Ok(common::elapsed_secs(start_time));
+    }
+
+    let intermediate = {
+        let dir = match ctx.target_dir {
+            Some(dir) => Path::new(dir).join("obj"),
+            None => Path::new("./target").join(ctx.profile).join("obj"),
+        };
+        std::fs::create_dir_all(&dir).map_err(|e| format!("obj dir error: {e}"))?;
+        dir.join(format!("{}.flat.elf", ctx.project_name))
+            .to_string_lossy()
+            .to_string()
+    };
+
+    let mut cmd = Command::new(ctx.linker.unwrap_or(default_linker));
+    cmd.arg("-nostdlib").arg("-static");
+    for obj in objects {
+        cmd.arg(obj);
+    }
+    for dir in ctx.lib_dirs {
+        cmd.arg(format!("-L{dir}"));
+    }
+    for lib in ctx.libs {
+        cmd.arg(format!("-l{lib}"));
+    }
+    for flag in ctx.ldflags {
+        cmd.arg(flag);
+    }
+    cmd.arg("-o").arg(&intermediate);
+
+    if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
+        eprintln!("[dcr] {:?}", cmd);
+    }
+    let program = cmd.get_program().to_string_lossy().into_owned();
+    let output = cmd.output().map_err(|err| {
+        if err.kind() == std::io::ErrorKind::NotFound {
+            format!("linker not found: {program} (check [toolchain].ld / PATH)")
+        } else {
+            format!("flat-bin link failed: {err}")
+        }
+    })?;
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        return Err(format!(
+            "flat-bin link failed:\nstdout: {stdout}\nstderr: {stderr}"
+        ));
+    }
+
+    objcopy_binary(ctx, &intermediate, &out_path)?;
+    Ok(common::elapsed_secs(start_time))
+}
+
+/// Archives objects into a static library.
 pub(crate) fn archive_static(
    ctx: &BuildContext,
    objects: &[String],
@@ -32,14 +237,12 @@ pub(crate) fn archive_static(
        return Ok(common::elapsed_secs(start_time));
    }

-    let archiver = ctx.archiver.unwrap_or(if cfg!(target_os = "windows") {
-        "lib"
-    } else {
-        "ar"
-    });
+    let archiver = ctx
+        .archiver
+        .unwrap_or_else(|| default_archiver(ctx.compiler));

    let mut cmd = Command::new(archiver);
-    if cfg!(target_os = "windows") && archiver == "lib" {
+    if cfg!(target_os = "windows") && is_msvc_lib(archiver) {
        cmd.arg("/nologo").arg(format!("/OUT:{lib_path}"));
    } else {
        cmd.arg("rcs").arg(&lib_path);
@@ -50,12 +253,17 @@ pub(crate) fn archive_static(
    run(ctx, cmd, start_time)
 }

+/// Links objects into a binary or library based on artifact kind.
 pub(crate) fn link_binary(
    ctx: &BuildContext,
    objects: &[String],
    default_linker: &str,
    start_time: Instant,
 ) -> Result<f64, String> {
+    if crate::utils::build::is_flat_bin(ctx.kind) {
+        return link_flat_binary(ctx, objects, default_linker, start_time);
+    }
+
    let mut cmd = Command::new(ctx.linker.unwrap_or(default_linker));
    if ctx.kind == "sharedlib" {
        if cfg!(target_os = "macos") {
@@ -111,11 +319,42 @@ pub(crate) fn link_binary(
    run(ctx, cmd, start_time)
 }

+/// Returns the default archiver name based on compiler and platform.
+fn default_archiver(compiler: &str) -> &'static str {
+    let c = compiler.to_lowercase();
+    if cfg!(target_os = "windows") {
+        if c.contains("cl") && !c.contains("clang") {
+            "lib"
+        } else if c.contains("clang") {
+            "llvm-ar"
+        } else {
+            "ar"
+        }
+    } else {
+        "ar"
+    }
+}
+
+/// Checks if the archiver is an MSVC lib tool.
+fn is_msvc_lib(archiver: &str) -> bool {
+    let a = archiver.to_lowercase();
+    a == "lib" || a == "lib.exe" || a.ends_with("\\lib.exe") || a.ends_with("/lib.exe")
+}
+
+/// Runs a command and handles success/failure with timing.
 fn run(ctx: &BuildContext, mut cmd: Command, start_time: Instant) -> Result<f64, String> {
    if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
        eprintln!("[dcr] {:?}", cmd);
    }
-    let output = cmd.output().map_err(|err| format!("Build failed: {err}"))?;
+    let program = cmd.get_program().to_string_lossy().into_owned();
+    let output = cmd.output().map_err(|err| {
+        let msg = err.to_string();
+        if err.kind() == std::io::ErrorKind::NotFound {
+            format!("linker not found: {program} (check [toolchain].ld / PATH)")
+        } else {
+            format!("Build failed: {msg}")
+        }
+    })?;
    if output.status.success() {
        Ok(common::elapsed_secs(start_time))
    } else {
@@ -124,3 +363,64 @@ fn run(ctx: &BuildContext, mut cmd: Command, start_time: Instant) -> Result<f64,
        Err(format!("Build failed:\nstdout: {stdout}\nstderr: {stderr}"))
    }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Default `bin` kind resolves via platform bin path.
+    #[test]
+    fn resolve_bin_default() {
+        let p = resolve_artifact_path("bin", "debug", "hello", None, None, None).unwrap();
+        assert_eq!(p, platform::bin_path("debug", "hello", None));
+    }
+
+    /// Custom `target_dir` places the binary under that directory.
+    #[test]
+    fn resolve_bin_custom_target_dir() {
+        let p = resolve_artifact_path("bin", "debug", "hello", Some("/out"), None, None).unwrap();
+        let name = if cfg!(windows) { "hello.exe" } else { "hello" };
+        let expected = Path::new("/out").join(name);
+        assert_eq!(p, expected.to_string_lossy());
+    }
+
+    /// `staticlib` kind resolves to a platform static library path.
+    #[test]
+    fn resolve_staticlib() {
+        let p = resolve_artifact_path("staticlib", "release", "mylib", Some("dist"), None, None)
+            .unwrap();
+        let name = if cfg!(windows) {
+            "mylib.lib"
+        } else {
+            "libmylib.a"
+        };
+        let expected = Path::new("dist").join(name);
+        assert_eq!(p, expected.to_string_lossy());
+    }
+
+    /// Custom output filename and extension override the default name.
+    #[test]
+    fn resolve_with_filename_ext() {
+        let p = resolve_artifact_path(
+            "bin",
+            "debug",
+            "pkg",
+            Some("/out"),
+            Some("KERNEL"),
+            Some("ELF"),
+        )
+        .unwrap();
+        assert_eq!(
+            p,
+            std::path::Path::new("/out")
+                .join("KERNEL.ELF")
+                .to_string_lossy()
+        );
+    }
+
+    /// `none` kind has no artifact path.
+    #[test]
+    fn resolve_none_kind() {
+        assert!(resolve_artifact_path("none", "debug", "x", None, None, None).is_none());
+    }
+}
--- a/src/core/build/builder/cc_common.rs
+++ b/src/core/build/builder/cc_common.rs
@@ -18,18 +18,25 @@
 use crate::core::build::builder::BuildContext;
 use crate::core::build::builder::artifact;
 use crate::core::build::common;
-use crate::utils::build::is_bare_metal_target;
+use crate::utils::build::{is_bare_metal_target, is_compile_only, is_flat_bin};
 use std::fs;
 use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::time::Instant;

+/// Compiles C/C++ sources and links/archives by kind (`bin`, libs, `flat-bin`, or compile-only).
+///
+/// Handles Qt preprocessing when enabled. Returns elapsed seconds.
 pub fn build(ctx: &BuildContext) -> Result<f64, String> {
    let compiler = if ctx.compiler.is_empty() {
        "cc"
    } else {
        ctx.compiler
    };
+    // Reject unsupported flat-bin with Qt
+    if is_flat_bin(ctx.kind) && ctx.qt {
+        return Err("flat-bin is not supported with build.qt = true".to_string());
+    }
    let start_time = Instant::now();
    let obj_dir = match ctx.target_dir {
        Some(dir) => Path::new(dir).join("obj"),
@@ -55,7 +62,7 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
    )?;
    let objects = build_objects(compiler, &sources, &obj_dir, ctx, "o", qt_include_path)?;

-    if ctx.kind == "none" || ctx.kind == "custom" {
+    if is_compile_only(ctx.kind) && !is_flat_bin(ctx.kind) {
        return Ok(common::elapsed_secs(start_time));
    }

@@ -66,6 +73,9 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
    artifact::link_binary(ctx, &objects, compiler, start_time)
 }

+/// Collects source files from the provided source roots for the build context.
+///
+/// Delegates to common source collection after resolving language-specific extensions.
 pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
    let extensions = source_extensions(ctx.language);
    common::collect_sources(
@@ -76,14 +86,19 @@ pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String>
    )
 }

+/// Source file extensions for `language` (owned `Vec` of static slices).
 fn source_extensions(language: &str) -> Vec<&'static str> {
    crate::core::build::common::source_extensions(language)
 }

+/// Retrieves default compiler flags for the specified build profile.
 fn default_flags(profile: &str) -> &'static [&'static str] {
    crate::utils::build::default_profile_flags(profile)
 }

+/// Compiles all provided sources into object files in parallel.
+///
+/// Prepares object file paths and spawns parallel tasks for each source compilation.
 fn build_objects(
    compiler: &str,
    sources: &[String],
@@ -97,6 +112,7 @@ fn build_objects(
        .map(|s| common::object_path(obj_dir, s, obj_ext))
        .collect();

+    // Compile objects in parallel
    common::parallel_build(
        sources.len(),
        |i| {
@@ -114,6 +130,9 @@ fn build_objects(
    Ok(objects)
 }

+/// Compiles a single source file to an object file.
+///
+/// Creates object directory if needed, checks for rebuild necessity, constructs and runs the compiler command with appropriate flags.
 fn build_object(
    compiler: &str,
    source: &str,
@@ -125,6 +144,7 @@ fn build_object(
        fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
    }

+    // Skip if object is already up to date
    if !common::needs_rebuild(source, obj_path) {
        return Ok(());
    }
@@ -142,7 +162,7 @@ fn build_object(
        cmd.arg("-fPIC");
    }

-    if (ctx.freestanding || is_bare_metal_target(ctx.target))
+    if (ctx.freestanding || is_bare_metal_target(ctx.target) || is_flat_bin(ctx.kind))
        && ctx.language.to_lowercase() != "asm"
    {
        cmd.arg("-ffreestanding");
@@ -178,8 +198,10 @@ fn build_object(
        }
    }

-    let use_dcr_defaults =
-        ctx.cflags.is_empty() && !(ctx.freestanding || is_bare_metal_target(ctx.target));
+    let use_dcr_defaults = ctx.cflags.is_empty()
+        && !(ctx.freestanding || is_bare_metal_target(ctx.target) || is_flat_bin(ctx.kind));
+
+    // Use default flags only if no custom flags and not special target
    if use_dcr_defaults {
        for flag in default_flags(ctx.profile) {
            cmd.arg(flag);
@@ -208,6 +230,7 @@ fn build_object(
    common::run_command_sync_output(&mut cmd)
 }

+/// Returns the assembly language flag for the compiler based on source extension.
 fn asm_lang_flag(source: &str) -> Option<&'static str> {
    crate::core::build::common::asm_lang_flag(source)
 }
--- a/src/core/build/builder/mod.rs
+++ b/src/core/build/builder/mod.rs
@@ -22,6 +22,7 @@ pub mod msvc;
 use crate::core::build::language::asm::{fasm, gas, masm, nasm};
 use crate::core::build::language::llvm_ir;

+/// Configuration context for the build process, including compiler, target, and output settings.
 pub struct BuildContext<'a> {
    pub profile: &'a str,
    pub project_name: &'a str,
@@ -56,6 +57,7 @@ pub struct BuildContext<'a> {
    pub qt: bool,
 }

+/// Trait defining the build interface for different compilers and languages.
 pub trait Builder {
    #[allow(dead_code)]
    fn id(&self) -> &'static str;
@@ -63,12 +65,19 @@ pub trait Builder {
    fn collect_sources(&self, ctx: &BuildContext) -> Result<Vec<String>, String>;
 }

+/// Concrete builder for C/C++ languages using gcc/clang.
 struct Cc;
+/// Concrete builder for MSVC and clang-cl.
 struct Msvc;
+/// Concrete builder for NASM assembly.
 struct Nasm;
+/// Concrete builder for GNU Assembler (gas).
 struct Gas;
+/// Concrete builder for MASM assembler.
 struct Masm;
+/// Concrete builder for FASM assembler.
 struct Fasm;
+/// Concrete builder for LLVM IR.
 struct Llc;

 impl Builder for Cc {
@@ -156,6 +165,7 @@ impl Builder for Llc {
 }

 pub fn builder_for(compiler: &str) -> &'static dyn Builder {
+    // Normalize compiler name to lowercase for matching.
    let c = compiler.to_lowercase();
    if c.contains("clang-cl") {
        return &Msvc;
@@ -181,6 +191,7 @@ pub fn builder_for(compiler: &str) -> &'static dyn Builder {
    &Cc
 }

+/// Main build entrypoint that validates the compiler and delegates to the selected builder.
 pub fn build(ctx: &BuildContext) -> Result<f64, String> {
    if !check_compiler_exists(ctx.compiler) {
        return Err(format!(
@@ -188,9 +199,11 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
            ctx.compiler
        ));
    }
+    // Delegate to the concrete builder's build method.
    builder_for(ctx.compiler).build(ctx)
 }

+/// True if `compiler --version` can be spawned (exit status is ignored).
 fn check_compiler_exists(compiler: &str) -> bool {
    let name = if compiler.is_empty() {
        "cc"
@@ -209,10 +222,12 @@ fn check_compiler_exists(compiler: &str) -> bool {
        .is_ok()
 }

+/// Collects source code files by delegating to the builder selected for the compiler.
 pub fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
    builder_for(ctx.compiler).collect_sources(ctx)
 }

+/// Unit test verifying that builder_for correctly identifies the builder for various compiler names.
 #[cfg(test)]
 mod tests {
    use super::*;
--- a/src/core/build/builder/msvc/mod.rs
+++ b/src/core/build/builder/msvc/mod.rs
@@ -15,14 +15,22 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.

+/// MSVC build backend for DCR.
+///
+/// This module provides the MSVC-specific build implementation for C and C++
+/// projects, including object compilation and linking for executables, static
+/// libraries, shared libraries, and flat binaries.
 use crate::core::build::builder::BuildContext;
+use crate::core::build::builder::artifact;
 use crate::core::build::common;
 use crate::platform;
+use crate::utils::build::{is_compile_only, is_flat_bin};
 use std::fs;
 use std::path::Path;
 use std::process::Command;
 use std::time::Instant;

+/// Builds the project target using the MSVC compiler.
 pub fn build(ctx: &BuildContext) -> Result<f64, String> {
    let compiler = if ctx.compiler.is_empty() {
        "cl"
@@ -33,6 +41,9 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
    if lang.contains("asm") {
        return Err("MSVC backend does not support build.language with asm".to_string());
    }
+    if is_flat_bin(ctx.kind) && ctx.qt {
+        return Err("flat-bin is not supported with build.qt = true".to_string());
+    }
    let start_time = Instant::now();
    let sources = collect_sources(ctx)?;
    let obj_dir = match ctx.target_dir {
@@ -41,18 +52,27 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
    };
    let objects = build_objects(compiler, &sources, &obj_dir, ctx, "obj")?;

-    if ctx.kind == "none" || ctx.kind == "custom" {
+    if is_compile_only(ctx.kind) && !is_flat_bin(ctx.kind) {
        return Ok(common::elapsed_secs(start_time));
    }

+    if is_flat_bin(ctx.kind) {
+        return link_flat_msvc(ctx, compiler, &objects, &obj_dir, start_time);
+    }
+
    if ctx.kind == "staticlib" {
        let lib_path = platform::lib_path(ctx.profile, ctx.project_name, ctx.target_dir);
        if !common::needs_link(&objects, &lib_path) {
            let elapsed = common::elapsed_secs(start_time);
            return Ok(elapsed);
        }
-        let mut cmd = Command::new(ctx.archiver.unwrap_or("lib"));
-        cmd.arg("/nologo").arg(format!("/OUT:{lib_path}"));
+        let archiver = ctx.archiver.unwrap_or("lib");
+        let mut cmd = Command::new(archiver);
+        if archiver == "lib" || archiver.eq_ignore_ascii_case("lib.exe") {
+            cmd.arg("/nologo").arg(format!("/OUT:{lib_path}"));
+        } else {
+            cmd.arg("rcs").arg(&lib_path);
+        }
        for obj in &objects {
            cmd.arg(obj);
        }
@@ -145,6 +165,63 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
    }
 }

+/// Links the flat binary output for MSVC build targets.
+fn link_flat_msvc(
+    ctx: &BuildContext,
+    compiler: &str,
+    objects: &[String],
+    obj_dir: &Path,
+    start_time: Instant,
+) -> Result<f64, String> {
+    let out_path = artifact::flat_output_path(ctx);
+    if !common::needs_link(objects, &out_path) {
+        return Ok(common::elapsed_secs(start_time));
+    }
+    fs::create_dir_all(obj_dir).map_err(|e| format!("obj dir error: {e}"))?;
+    let intermediate = obj_dir
+        .join(format!("{}.flat.exe", ctx.project_name))
+        .to_string_lossy()
+        .to_string();
+
+    let mut cmd = Command::new(compiler);
+    cmd.arg("/nologo");
+    for obj in objects {
+        cmd.arg(obj);
+    }
+    for flag in ctx.cflags {
+        cmd.arg(flag);
+    }
+    for dir in ctx.lib_dirs {
+        cmd.arg(format!("/LIBPATH:{dir}"));
+    }
+    for lib in ctx.libs {
+        if lib.to_lowercase().ends_with(".lib") {
+            cmd.arg(lib);
+        } else {
+            cmd.arg(format!("{lib}.lib"));
+        }
+    }
+    cmd.arg(format!("/Fe:{intermediate}"));
+    if !ctx.ldflags.is_empty() {
+        cmd.arg("/link");
+        for flag in ctx.ldflags {
+            cmd.arg(flag);
+        }
+    }
+    if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
+        eprintln!("[dcr] {:?}", cmd);
+    }
+    let status = cmd
+        .status()
+        .map_err(|e| format!("flat-bin link failed: {e}"))?;
+    if !status.success() {
+        return Err("flat-bin link failed".to_string());
+    }
+    artifact::objcopy_binary(ctx, &intermediate, &out_path)?;
+    Ok(common::elapsed_secs(start_time))
+}
+
+/// Collects all source files for the build based on language extensions.
 pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
    let extensions = source_extensions(ctx.language);
    common::collect_sources(
@@ -155,10 +232,12 @@ pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String>
    )
 }

+/// Source file extensions for `language` (owned `Vec` of static slices).
 fn source_extensions(language: &str) -> Vec<&'static str> {
    crate::core::build::common::source_extensions(language)
 }

+/// Maps the language and standard version to the corresponding MSVC flag string.
 fn msvc_standard_flag(language: &str, standard: &str) -> Result<String, String> {
    let lang = language.to_lowercase();
    let std = standard.to_lowercase();
@@ -182,6 +261,7 @@ fn msvc_standard_flag(language: &str, standard: &str) -> Result<String, String>
    Err("Unsupported language".to_string())
 }

+/// Returns the MSVC architecture flag based on the target platform.
 fn msvc_arch_flag(platform: Option<&str>) -> Option<&'static str> {
    let raw = platform?.trim();
    if raw.is_empty() {
@@ -199,6 +279,7 @@ fn msvc_arch_flag(platform: Option<&str>) -> Option<&'static str> {
    }
 }

+/// Returns default compiler flags for the specified build profile.
 fn default_flags(profile: &str) -> &'static [&'static str] {
    match profile {
        "release" => &["/O2", "/DNDEBUG"],
@@ -207,6 +288,7 @@ fn default_flags(profile: &str) -> &'static [&'static str] {
    }
 }

+/// Compiles all sources into object files using parallel processing.
 fn build_objects(
    compiler: &str,
    sources: &[String],
@@ -228,6 +310,7 @@ fn build_objects(
    Ok(objects)
 }

+/// Compiles a single source file to an object file.
 fn build_object(
    compiler: &str,
    source: &str,
@@ -300,6 +383,7 @@ fn build_object(
    let mut headers = Vec::new();
    let mut clean_stdout = String::new();

+    // Parse compiler output to extract include file notes for dependency generation
    for line in stdout.lines() {
        if let Some(stripped) = line.strip_prefix("Note: including file:") {
            headers.push(stripped.trim().to_string());
--- a/src/core/build/cache.rs
+++ b/src/core/build/cache.rs
@@ -21,6 +21,17 @@ use sha2::{Digest, Sha256};
 use std::fs;
 use std::path::{Path, PathBuf};

+/// Computes a build fingerprint by hashing context fields and file metadata (SHA-256).
+///
+/// Includes `dcr.toml` (required) and `dcr.lock` when present, plus path/size/mtime
+/// for each source, header, and library file.
+///
+/// # Parameters
+/// - `ctx`: Build context (profile, tools, flags, dirs, …).
+/// - `sources` / `headers` / `lib_files`: Inputs whose metadata enters the hash.
+///
+/// # Returns
+/// Hex-encoded fingerprint, or an error if `dcr.toml` or a listed file cannot be read.
 pub(crate) fn compute_build_fingerprint(
    ctx: &BuildContext,
    sources: &[String],
@@ -61,12 +72,14 @@ pub(crate) fn compute_build_fingerprint(
    for value in ctx.ldflags {
        hasher.update(value.as_bytes());
    }
+    // Include project metadata from dcr.toml in the fingerprint
    let toml =
        fs::read_to_string("dcr.toml").map_err(|err| format!("Failed to read dcr.toml: {err}"))?;
    hasher.update(toml.as_bytes());
    if let Ok(lock) = fs::read_to_string("dcr.lock") {
        hasher.update(lock.as_bytes());
    }
+    // Include source, header, and library files in the fingerprint
    for source in sources {
        let path = Path::new(source);
        update_hasher_with_file(&mut hasher, path)?;
@@ -80,6 +93,14 @@ pub(crate) fn compute_build_fingerprint(
    Ok(to_hex(&hasher.finalize()))
 }

+/// Whether the build can be skipped: main artifact exists and cache hash matches.
+///
+/// # Parameters
+/// - `ctx`: Used to locate the output artifact and `.dcr-build.hash`.
+/// - `fingerprint`: Fresh hash from [`compute_build_fingerprint`].
+///
+/// # Returns
+/// `true` only when both the artifact and matching cache file are present.
 pub(crate) fn should_skip_build(ctx: &BuildContext, fingerprint: &str) -> bool {
    let output = build_output_path(ctx);
    if !Path::new(&output).is_file() {
@@ -90,6 +111,7 @@ pub(crate) fn should_skip_build(ctx: &BuildContext, fingerprint: &str) -> bool {
    cached.trim() == fingerprint
 }

+/// Persists the build fingerprint to the cache file on disk.
 pub(crate) fn write_build_fingerprint(ctx: &BuildContext, fingerprint: &str) -> Result<(), String> {
    let cache_path = build_cache_path(ctx.profile, ctx.target_dir);
    if let Some(parent) = cache_path.parent() {
@@ -99,6 +121,7 @@ pub(crate) fn write_build_fingerprint(ctx: &BuildContext, fingerprint: &str) ->
        .map_err(|err| format!("Failed to write cache: {err}"))
 }

+/// Returns the path to the build cache hash file based on profile and target directory.
 fn build_cache_path(profile: &str, target_dir: Option<&str>) -> PathBuf {
    match target_dir {
        Some(dir) => Path::new(dir).join(".dcr-build.hash"),
@@ -106,31 +129,26 @@ fn build_cache_path(profile: &str, target_dir: Option<&str>) -> PathBuf {
    }
 }

-fn build_output_path(ctx: &BuildContext) -> String {
-    let name = ctx.output_filename.unwrap_or(ctx.project_name);
-    let ext = ctx.output_extension.unwrap_or("");
-
-    let final_name = if ext.is_empty() {
-        name.to_string()
-    } else {
-        format!("{}.{}", name, ext)
-    };
-
-    if ctx.kind == "staticlib" {
-        return crate::platform::lib_path(ctx.profile, &final_name, ctx.target_dir);
-    }
-    if ctx.kind == "sharedlib" {
-        return crate::platform::shared_lib_path(ctx.profile, &final_name, ctx.target_dir);
-    }
-    if ctx.kind == "efi" {
-        return crate::platform::efi_path(ctx.profile, &final_name, ctx.target_dir);
-    }
-    if ctx.kind == "elf" {
-        return crate::platform::elf_path(ctx.profile, &final_name, ctx.target_dir);
-    }
-    crate::platform::bin_path(ctx.profile, &final_name, ctx.target_dir)
+/// Resolves the output path for the build artifact using the provided context.
+pub fn build_output_path(ctx: &BuildContext) -> String {
+    crate::core::build::builder::artifact::resolve_artifact_path(
+        ctx.kind,
+        ctx.profile,
+        ctx.project_name,
+        ctx.target_dir,
+        ctx.output_filename,
+        ctx.output_extension,
+    )
+    .unwrap_or_else(|| {
+        crate::platform::bin_path(
+            ctx.profile,
+            ctx.output_filename.unwrap_or(ctx.project_name),
+            ctx.target_dir,
+        )
+    })
 }

+/// Collects header files from source roots and include directories, filtering out excluded paths.
 pub(crate) fn collect_header_files(
    ctx: &BuildContext,
    project_root: &Path,
@@ -159,13 +177,20 @@ pub(crate) fn collect_header_files(
        if !root.exists() {
            continue;
        }
-        collect_header_files_rec(&root, &mut out, ctx.exclude_dirs, ctx.include_paths)?;
+        if root.is_file() {
+            if is_header_file(&root) {
+                out.push(root);
+            }
+        } else {
+            collect_header_files_rec(&root, &mut out, ctx.exclude_dirs, ctx.include_paths)?;
+        }
    }
    out.sort();
    out.dedup();
    Ok(out)
 }

+/// Recursively scans a directory to collect header files, respecting exclusion rules.
 fn collect_header_files_rec(
    dir: &Path,
    out: &mut Vec<PathBuf>,
@@ -198,11 +223,13 @@ fn collect_header_files_rec(
    Ok(())
 }

+/// Checks if the given path has a header file extension.
 fn is_header_file(path: &Path) -> bool {
    let ext = path.extension().and_then(|v| v.to_str()).unwrap_or("");
    matches!(ext, "h" | "hpp" | "hh" | "hxx" | "inc")
 }

+/// Collects library files from lib directories using platform-specific candidates.
 pub(crate) fn collect_lib_files(ctx: &BuildContext) -> Vec<PathBuf> {
    let mut out = Vec::new();
    for dir in ctx.lib_dirs {
@@ -219,6 +246,7 @@ pub(crate) fn collect_lib_files(ctx: &BuildContext) -> Vec<PathBuf> {
    out
 }

+/// Candidate library filenames for the **host** OS (`cfg!(target_os = …)`).
 fn lib_candidates(name: &str) -> Vec<String> {
    if cfg!(target_os = "windows") {
        return vec![format!("{name}.lib")];
@@ -237,6 +265,7 @@ fn lib_candidates(name: &str) -> Vec<String> {
    ]
 }

+/// Updates the hasher with the file's path, size, and last modification time.
 fn update_hasher_with_file(hasher: &mut Sha256, path: &Path) -> Result<(), String> {
    hasher.update(path.to_string_lossy().as_bytes());
    let meta = fs::metadata(path).map_err(|err| format!("source read error: {err}"))?;
@@ -249,6 +278,7 @@ fn update_hasher_with_file(hasher: &mut Sha256, path: &Path) -> Result<(), Strin
    Ok(())
 }

+/// Converts a byte slice containing the SHA256 hash to a hexadecimal string.
 fn to_hex(bytes: &[u8]) -> String {
    crate::utils::fs::to_hex(bytes)
 }
--- a/src/core/build/common.rs
+++ b/src/core/build/common.rs
@@ -16,17 +16,87 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.

 use std::fs;
+use std::io::{self, IsTerminal, Write};
 use std::path::{Path, PathBuf};
 use std::process::Command;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Mutex, OnceLock};
 use std::time::Instant;

 static OUTPUT_MUTEX: OnceLock<Mutex<()>> = OnceLock::new();
+static PROGRESS_LABEL: OnceLock<Mutex<Option<String>>> = OnceLock::new();
+static PROGRESS_DIRTY: AtomicBool = AtomicBool::new(false);

+/// Returns a static mutex used to synchronize access to stderr during progress reporting.
+/// This ensures thread-safe output when multiple build threads write to the terminal.
 pub fn get_output_lock() -> &'static Mutex<()> {
    OUTPUT_MUTEX.get_or_init(|| Mutex::new(()))
 }

+/// Initializes the shared progress label storage.
+fn progress_label_lock() -> &'static Mutex<Option<String>> {
+    PROGRESS_LABEL.get_or_init(|| Mutex::new(None))
+}
+
+/// Sets the label text that will be shown next to the compile progress counter.
+/// The label is cleared after the progress line is finished.
+pub fn set_progress_label(label: Option<String>) {
+    *progress_label_lock().lock().unwrap() = label;
+}
+
+/// Finishes the current progress line by clearing the label and flushing the line if it was dirty.
+/// This is called when a build step completes normally.
+pub fn finish_progress_line() {
+    let was_dirty = PROGRESS_DIRTY.swap(false, Ordering::SeqCst);
+    *progress_label_lock().lock().unwrap() = None;
+    if !was_dirty {
+        return;
+    }
+    if io::stderr().is_terminal() {
+        let _guard = get_output_lock().lock().unwrap();
+        let _ = writeln!(io::stderr());
+        let _ = io::stderr().flush();
+    }
+}
+
+/// Interrupts the current progress line (if any) and flushes it to stderr.
+/// Used when a build step produces output that should interrupt the progress display.
+pub fn interrupt_progress_for_output() {
+    if !PROGRESS_DIRTY.swap(false, Ordering::SeqCst) {
+        return;
+    }
+    if io::stderr().is_terminal() {
+        let _guard = get_output_lock().lock().unwrap();
+        let _ = writeln!(io::stderr());
+        let _ = io::stderr().flush();
+    }
+}
+
+/// Reports the current compile progress to stderr in the format "label [done/total]".
+/// Only prints if the terminal is attached and the label is set.
+/// Updates the dirty flag so the line can be overwritten on the next call.
+fn report_compile_progress(done: usize, total: usize) {
+    let label = progress_label_lock().lock().unwrap().clone();
+    let Some(label) = label else {
+        return;
+    };
+    if !io::stderr().is_terminal() {
+        return;
+    }
+    let _guard = get_output_lock().lock().unwrap();
+    let msg = format!("{label}  [{done}/{total}]");
+    if PROGRESS_DIRTY.load(Ordering::SeqCst) {
+        eprint!("\r{msg:<80}");
+    } else {
+        eprint!("{msg}");
+    }
+    let _ = io::stderr().flush();
+    PROGRESS_DIRTY.store(true, Ordering::SeqCst);
+}
+
+/// Recursively collects all source files under the given roots that match the provided extensions.
+/// Directories listed in exclude_dirs are skipped unless overridden by include_paths.
+/// Returns a sorted list of normalized source paths or an error string.
 pub fn collect_sources(
    roots: &[PathBuf],
    extensions: &[&str],
@@ -35,12 +105,22 @@ pub fn collect_sources(
 ) -> Result<Vec<String>, String> {
    let mut sources = Vec::new();
    for root in roots {
-        collect_sources_rec(root, extensions, &mut sources, exclude_dirs, include_paths)?;
+        if root.is_file() {
+            if let Some(ext) = root.extension().and_then(|e| e.to_str())
+                && extensions.contains(&ext.to_lowercase().as_str())
+            {
+                sources.push(root.to_string_lossy().to_string());
+            }
+        } else {
+            collect_sources_rec(root, extensions, &mut sources, exclude_dirs, include_paths)?;
+        }
    }
    sources.sort();
    Ok(sources)
 }

+/// Recursively walks a directory tree to collect source files.
+/// Skips excluded directories unless they are explicitly allowed by include_paths.
 fn collect_sources_rec(
    dir: &Path,
    extensions: &[&str],
@@ -88,6 +168,8 @@ fn collect_sources_rec(
    Ok(())
 }

+/// Determines whether a path should be excluded from source collection.
+/// Returns false if the path is explicitly allowed by include_paths (even if it matches an exclude).
 pub fn is_excluded(path: &Path, exclude_dirs: &[PathBuf], include_paths: &[String]) -> bool {
    if matches_patterns(path, include_paths, true) {
        return false;
@@ -95,9 +177,33 @@ pub fn is_excluded(path: &Path, exclude_dirs: &[PathBuf], include_paths: &[Strin
    if matches_patterns(path, include_paths, false) {
        return true;
    }
-    exclude_dirs.iter().any(|dir| path.starts_with(dir))
+    exclude_dirs.iter().any(|dir| path_is_under(path, dir))
 }

+/// Checks if a path is under a given prefix, handling both absolute and relative paths
+/// and normalizing Windows-style separators for cross-platform comparison.
+fn path_is_under(path: &Path, prefix: &Path) -> bool {
+    if path.starts_with(prefix) {
+        return true;
+    }
+    match (fs::canonicalize(path), fs::canonicalize(prefix)) {
+        (Ok(p), Ok(pref)) => p.starts_with(pref),
+        _ => {
+            let p = path.to_string_lossy().replace('\\', "/");
+            let pref = prefix.to_string_lossy().replace('\\', "/");
+            if p == pref || p.starts_with(&format!("{pref}/")) {
+                return true;
+            }
+            let p = p.strip_prefix("/private").unwrap_or(&p);
+            let pref = pref.strip_prefix("/private").unwrap_or(&pref);
+            p == pref || p.starts_with(&format!("{pref}/"))
+        }
+    }
+}
+
+/// Matches a path against include/exclude glob and path patterns.
+/// Positive patterns allow files; negative patterns (starting with !) exclude them.
+/// Returns true if the path matches any rule.
 fn matches_patterns(path: &Path, patterns: &[String], positive: bool) -> bool {
    if patterns.is_empty() {
        return false;
@@ -162,10 +268,20 @@ fn matches_patterns(path: &Path, patterns: &[String], positive: bool) -> bool {
    false
 }

+/// Returns true if the string contains any glob magic characters (*, ?, or [).
 pub fn has_glob_magic(value: &str) -> bool {
    value.chars().any(|c| matches!(c, '*' | '?' | '['))
 }

+/// Returns a GCC/Clang `-x` language for assembly sources.
+///
+/// # Parameters
+/// - `source`: Source file path (extension decides the dialect).
+///
+/// # Returns
+/// - `Some("assembler-with-cpp")` for `.S`
+/// - `Some("assembler")` for `.s` / `.asm`
+/// - `None` for other extensions
 pub fn asm_lang_flag(source: &str) -> Option<&'static str> {
    let ext = Path::new(source).extension().and_then(|v| v.to_str())?;
    match ext {
@@ -175,6 +291,8 @@ pub fn asm_lang_flag(source: &str) -> Option<&'static str> {
    }
 }

+/// Returns the list of file extensions associated with the given language token(s).
+/// Splits comma-separated tokens and falls back to .c if no language is recognized.
 pub fn source_extensions(language: &str) -> Vec<&'static str> {
    let mut out = Vec::new();
    for part in language.split(',').map(|s| s.trim()) {
@@ -188,10 +306,13 @@ pub fn source_extensions(language: &str) -> Vec<&'static str> {
    out
 }

+/// Returns elapsed time in seconds with two decimal places for display purposes.
 pub fn elapsed_secs(start: Instant) -> f64 {
    ((start.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0
 }

+/// Spawns a fixed number of worker threads to parallelize a build task.
+/// Reports progress after each task completes.
 pub fn parallel_build<F>(total_tasks: usize, task_fn: F, max_jobs: usize) -> Result<(), String>
 where
    F: Fn(usize) -> Result<(), String> + Sync + Send,
@@ -206,8 +327,13 @@ where
    };

    let counter = std::sync::atomic::AtomicUsize::new(0);
+    let completed = std::sync::atomic::AtomicUsize::new(0);
    let err_msg = std::sync::Mutex::new(None);

+    if total_tasks > 0 {
+        report_compile_progress(0, total_tasks);
+    }
+
    std::thread::scope(|s| {
        for _ in 0..num_threads {
            s.spawn(|| {
@@ -228,6 +354,9 @@ where
                        }
                        break;
                    }
+
+                    let done = completed.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1;
+                    report_compile_progress(done, total_tasks);
                }
            });
        }
@@ -240,11 +369,24 @@ where
    Ok(())
 }

+/// Runs a command, prints stdout/stderr to the terminal (interrupting progress),
+/// and returns `Ok(())` or `Err` based on exit status.
 pub fn run_command_sync_output(cmd: &mut Command) -> Result<(), String> {
-    let output = cmd.output().map_err(|err| format!("Build failed: {err}"))?;
-    let _guard = OUTPUT_MUTEX.get_or_init(|| Mutex::new(())).lock().unwrap();
+    let program = cmd.get_program().to_string_lossy().into_owned();
+    let output = cmd.output().map_err(|err| {
+        if err.kind() == std::io::ErrorKind::NotFound {
+            format!("{program} not found (check PATH / [toolchain])")
+        } else {
+            format!("Build failed: {err}")
+        }
+    })?;
+    let has_out = !output.stdout.is_empty() || !output.stderr.is_empty();
+    if has_out {
+        interrupt_progress_for_output();
+    }
+    let _guard = get_output_lock().lock().unwrap();
    if !output.stdout.is_empty() {
-        print!("{}", String::from_utf8_lossy(&output.stdout));
+        eprint!("{}", String::from_utf8_lossy(&output.stdout));
    }
    if !output.stderr.is_empty() {
        eprint!("{}", String::from_utf8_lossy(&output.stderr));
@@ -256,6 +398,8 @@ pub fn run_command_sync_output(cmd: &mut Command) -> Result<(), String> {
    }
 }

+/// Normalizes a source path to be relative to the current working directory when possible.
+/// Returns the original path unchanged if it cannot be made relative.
 pub fn normalize_source_path(path: &Path) -> String {
    if !path.is_absolute() {
        return path.to_string_lossy().to_string();
@@ -268,6 +412,8 @@ pub fn normalize_source_path(path: &Path) -> String {
    path.to_string_lossy().to_string()
 }

+/// Computes the output object file path by stripping the leading ./ and adjusting the extension.
+/// Places the object in the specified obj_dir while preserving directory structure.
 pub fn object_path(obj_dir: &Path, source: &str, obj_ext: &str) -> String {
    let src_path = Path::new(source);
    let stripped = src_path.strip_prefix("./").unwrap_or(src_path);
@@ -297,9 +443,19 @@ pub fn object_path(obj_dir: &Path, source: &str, obj_ext: &str) -> String {
    } else {
        out.set_extension(obj_ext);
    }
-    out.to_string_lossy().to_string()
+    out.to_string_lossy().replace('\\', "/")
 }

+/// Checks whether a source file needs to be rebuilt.
+///
+/// Compares mtimes of the source, object, and deps listed in the sibling `.d` file.
+///
+/// # Parameters
+/// - `source`: Source path.
+/// - `object`: Object path (`.d` is derived by changing the extension).
+///
+/// # Returns
+/// `true` if the object is missing, older than source/deps, or a dep is missing.
 pub fn needs_rebuild(source: &str, object: &str) -> bool {
    let src_time = fs::metadata(source).and_then(|m| m.modified());
    let obj_time = fs::metadata(object).and_then(|m| m.modified());
@@ -335,6 +491,14 @@ pub fn needs_rebuild(source: &str, object: &str) -> bool {
    false
 }

+/// Checks whether the output executable needs to be relinked.
+///
+/// # Parameters
+/// - `objects`: Object file paths that feed the link step.
+/// - `output_path`: Linked artifact path.
+///
+/// # Returns
+/// `true` if the output is missing or any object is newer than it.
 pub fn needs_link(objects: &[String], output_path: &str) -> bool {
    let out_meta = match fs::metadata(output_path) {
        Ok(m) => m,
@@ -360,6 +524,8 @@ pub fn needs_link(objects: &[String], output_path: &str) -> bool {
    false
 }

+/// Parses a dependency file (.d) produced by GCC or MSVC compilers.
+/// Extracts all dependency paths, handling escaped newlines and Windows-style paths.
 fn parse_d_file(content: &str) -> Vec<String> {
    let mut deps = Vec::new();
    let mut target_end = 0;
@@ -400,7 +566,11 @@ fn parse_d_file(content: &str) -> Vec<String> {
            }
            in_escape = false;
        } else if c == '\\' {
-            in_escape = true;
+            match chars.peek() {
+                Some('\n' | '\r' | ' ' | '\t' | '\\') => in_escape = true,
+                Some(_) => current_path.push('\\'),
+                None => current_path.push('\\'),
+            }
        } else if c.is_whitespace() {
            if !current_path.is_empty() {
                deps.push(current_path.clone());
@@ -427,12 +597,18 @@ mod tests {
    static TEST_COUNTER: AtomicUsize = AtomicUsize::new(0);
    static CWD_LOCK: Mutex<()> = Mutex::new(());

+    fn cwd_lock() -> std::sync::MutexGuard<'static, ()> {
+        CWD_LOCK
+            .lock()
+            .unwrap_or_else(|poisoned| poisoned.into_inner())
+    }
+
    fn temp_dir(prefix: &str) -> PathBuf {
        let n = TEST_COUNTER.fetch_add(1, Ordering::SeqCst);
        let dir = std::env::temp_dir().join(format!("dcr_test_{prefix}_{n}"));
        let _ = fs::remove_dir_all(&dir);
        fs::create_dir_all(&dir).unwrap();
-        dir
+        fs::canonicalize(&dir).unwrap_or(dir)
    }

    fn default_roots() -> Vec<PathBuf> {
@@ -597,7 +773,7 @@ mod tests {
        fs::write(src.join("utils.c"), "").unwrap();
        fs::write(src.join("README.md"), "").unwrap(); // should be ignored

-        let _guard = CWD_LOCK.lock().unwrap();
+        let _guard = cwd_lock();
        let prev = std::env::current_dir().unwrap();
        std::env::set_current_dir(&dir).unwrap();
        let include: Vec<String> = Vec::new();
@@ -621,7 +797,7 @@ mod tests {
        fs::write(src.join("other.cc"), "").unwrap();
        fs::write(src.join("skip.c"), "").unwrap(); // should be ignored

-        let _guard = CWD_LOCK.lock().unwrap();
+        let _guard = cwd_lock();
        let prev = std::env::current_dir().unwrap();
        std::env::set_current_dir(&dir).unwrap();
        let include: Vec<String> = Vec::new();
@@ -639,7 +815,7 @@ mod tests {
        let src = dir.join("src");
        fs::create_dir_all(&src).unwrap();

-        let _guard = CWD_LOCK.lock().unwrap();
+        let _guard = cwd_lock();
        let prev = std::env::current_dir().unwrap();
        std::env::set_current_dir(&dir).unwrap();
        let include: Vec<String> = Vec::new();
@@ -661,7 +837,7 @@ mod tests {
        fs::write(vendor.join("lib.c"), "").unwrap(); // should be excluded

        let exclude = vec![vendor.clone()];
-        let _guard = CWD_LOCK.lock().unwrap();
+        let _guard = cwd_lock();
        let prev = std::env::current_dir().unwrap();
        std::env::set_current_dir(&dir).unwrap();
        let include: Vec<String> = Vec::new();
@@ -683,7 +859,7 @@ mod tests {
        fs::write(src.join("main.c"), "").unwrap();
        fs::write(sub.join("nested.c"), "").unwrap();

-        let _guard = CWD_LOCK.lock().unwrap();
+        let _guard = cwd_lock();
        let prev = std::env::current_dir().unwrap();
        std::env::set_current_dir(&dir).unwrap();
        let include: Vec<String> = Vec::new();
@@ -707,7 +883,7 @@ mod tests {

        let exclude = vec![boot.clone()];
        let include = vec!["src/boot/arch/**".to_string()];
-        let _guard = CWD_LOCK.lock().unwrap();
+        let _guard = cwd_lock();
        let prev = std::env::current_dir().unwrap();
        std::env::set_current_dir(&dir).unwrap();
        let roots = default_roots();
@@ -734,7 +910,7 @@ mod tests {
            "!src/legacy/**".to_string(),
            "src/legacy/allow/**".to_string(),
        ];
-        let _guard = CWD_LOCK.lock().unwrap();
+        let _guard = cwd_lock();
        let prev = std::env::current_dir().unwrap();
        std::env::set_current_dir(&dir).unwrap();
        let roots = default_roots();
@@ -757,7 +933,7 @@ mod tests {

        let exclude: Vec<PathBuf> = Vec::new();
        let include = vec!["!src/gen/**".to_string()];
-        let _guard = CWD_LOCK.lock().unwrap();
+        let _guard = cwd_lock();
        let prev = std::env::current_dir().unwrap();
        std::env::set_current_dir(&dir).unwrap();
        let roots = default_roots();
@@ -792,36 +968,44 @@ mod tests {
    #[test]
    fn needs_rebuild_header_modified() {
        let dir = temp_dir("rebuild_header");
-        let src = dir.join("test.c");
-        let header = dir.join("test.h");
-        let obj = dir.join("test.o");
-        let d_file = dir.join("test.d");
+        fs::write(dir.join("test.c"), "int main() {}").unwrap();
+        fs::write(dir.join("test.h"), "#define A 1").unwrap();
+        fs::write(dir.join("test.o"), "").unwrap();

-        fs::write(&src, "int main() {}").unwrap();
-        fs::write(&header, "#define A 1").unwrap();
-        std::thread::sleep(std::time::Duration::from_millis(50));
-        fs::write(&obj, "").unwrap();
-
-        let d_content = format!(
-            "{}: {} {}",
-            obj.to_string_lossy(),
-            src.to_string_lossy(),
-            header.to_string_lossy()
-        );
-        fs::write(&d_file, d_content).unwrap();
+        let _guard = cwd_lock();
+        let prev = std::env::current_dir().unwrap();
+        std::env::set_current_dir(&dir).unwrap();

+        fs::write("test.d", "test.o: test.c missing.h").unwrap();
        assert!(
-            !needs_rebuild(&src.to_string_lossy(), &obj.to_string_lossy()),
-            "should be fresh"
+            needs_rebuild("test.c", "test.o"),
+            "missing dep in .d must force rebuild"
        );

-        std::thread::sleep(std::time::Duration::from_millis(50));
-        fs::write(&header, "#define A 2").unwrap(); // modify header
-
+        fs::write("test.h", "#define A 1").unwrap();
+        std::thread::sleep(std::time::Duration::from_secs(2));
+        fs::write("test.o", "obj").unwrap();
+        fs::write("test.d", "test.o: test.c test.h").unwrap();
        assert!(
-            needs_rebuild(&src.to_string_lossy(), &obj.to_string_lossy()),
+            !needs_rebuild("test.c", "test.o"),
+            "object newer than source and headers should be fresh"
+        );
+
+        std::thread::sleep(std::time::Duration::from_secs(2));
+        fs::write("test.h", "#define A 2").unwrap();
+        assert!(
+            needs_rebuild("test.c", "test.o"),
            "changed header should trigger rebuild"
        );
+
+        std::env::set_current_dir(prev).unwrap();
+    }
+
+    #[test]
+    fn parse_d_file_keeps_windows_path_separators() {
+        let content = r"target\obj\main.obj: src\main.c src\utils.h";
+        let deps = parse_d_file(content);
+        assert_eq!(deps, vec![r"src\main.c", r"src\utils.h"]);
    }

    #[test]
--- a/src/core/build/engine.rs
+++ b/src/core/build/engine.rs
@@ -15,6 +15,8 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.

+/// Core build engine module for DCR.
+/// This module provides the main build logic for projects and workspaces.
 use crate::core::build::builder::{BuildContext, build as build_project, collect_sources};
 use crate::core::build::cache::{
    collect_header_files, collect_lib_files, compute_build_fingerprint, should_skip_build,
@@ -36,10 +38,11 @@ use crate::core::build_config::Config;
 use crate::core::deps::{register, resolve_deps};
 use crate::core::workspace::parse_workspace;
 use crate::utils::build::{
-    get_bool_with_profile, get_config_opt, get_config_str, get_language_with_profile,
-    is_bare_metal_target, normalize_kind, normalize_platform, normalize_target,
+    default_target_triple, get_bool_with_profile, get_config_opt, get_config_str,
+    get_language_with_profile, is_bare_metal_target, normalize_kind, normalize_platform,
    normalize_target_os, parse_version_info, prepend_clang_target_flag, primary_language,
-    resolve_compiler, resolve_pkg_config_flags, resolve_tool, substitute_vars,
+    resolve_artifact_target_dir, resolve_compiler, resolve_pkg_config_flags, resolve_tool,
+    substitute_vars,
 };
 use crate::utils::fs::check_dir;
 use std::fs;
@@ -48,6 +51,7 @@ use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::time::Instant;

+/// Ensures that target directories exist for the build output.
 fn ensure_target_dirs(
    project_root: &Path,
    items: &[String],
@@ -61,36 +65,22 @@ fn ensure_target_dirs(
    if let Some(dir) = &target_dir {
        let _ = fs::create_dir_all(dir);
    } else {
-        let default_dir = if cfg!(target_os = "linux") {
-            let arch = std::env::consts::ARCH;
-            format!("{arch}-unknown-linux-gnu/{profile}")
-        } else if cfg!(any(
-            target_os = "freebsd",
-            target_os = "openbsd",
-            target_os = "netbsd",
-            target_os = "dragonfly"
-        )) {
-            let arch = std::env::consts::ARCH;
-            let os = std::env::consts::OS;
-            format!("{arch}-unknown-{os}/{profile}")
-        } else {
-            profile.to_string()
-        };
-        let target_path = project_root.join("target");
-        let target_items = check_dir(target_path.to_str()).unwrap_or_default();
-        if !target_items.contains(&default_dir) {
-            let _ = fs::create_dir_all(target_path.join(&default_dir));
-        }
+        let _ = fs::create_dir_all(
+            project_root.join(crate::utils::build::native_host_target_rel(profile)),
+        );
    }
 }

+/// Runs the project build and returns the elapsed time in seconds or an error.
 fn run_compile(
    ctx: &BuildContext,
    _cancel: &Arc<AtomicBool>,
    _rep: &mut dyn BuildReporter,
 ) -> Result<f64, String> {
    let start_time = Instant::now();
-    match build_project(ctx) {
+    let result = build_project(ctx);
+    common::finish_progress_line();
+    match result {
        Ok(times) => {
            let times = if times == 0.0 {
                ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0
@@ -103,8 +93,16 @@ fn run_compile(
    }
 }

-// Library entry point: run a build described by `req`, streaming progress to
-// `rep`. The CLI wraps this with a CliReporter; TUI/GUI/MCP plug in their own.
+/// Library entry point: run a build described by `req`, streaming progress to
+/// `rep`. The CLI wraps this with a CliReporter; TUI/GUI/MCP plug in their own.
+///
+/// # Parameters
+/// - `root`: Project or workspace root containing `dcr.toml`.
+/// - `req`: Profile, target, force/verbose, optional member, cancel flag.
+/// - `rep`: Progress sink for build events.
+///
+/// # Returns
+/// `BuildOutcome` with elapsed seconds, or `BuildError` on failure/cancel.
 pub fn run_build(
    root: &Path,
    req: &BuildRequest,
@@ -124,6 +122,7 @@ pub fn run_build(
    Ok(BuildOutcome { secs })
 }

+/// Orchestrates the build for the specified profile and target, handling workspaces and projects.
 #[allow(unused_variables, clippy::too_many_arguments)]
 fn build_all(
    root: &Path,
@@ -157,6 +156,7 @@ fn build_all(
                &member.path,
                profile,
                target,
+                target.is_some_and(|t| !t.trim().is_empty()),
                &[],
                force,
                verbose,
@@ -165,28 +165,53 @@ fn build_all(
                &mut *rep,
            )?;
        }
+        if let Some(archive) = &config.typed().archive {
+            #[cfg(feature = "archive")]
+            {
+                super::archive::pack_archive(root, archive, profile)?;
+            }
+            #[cfg(not(feature = "archive"))]
+            {
+                let _ = (archive, profile);
+                return Err(
+                    "disk image packing requires building dcr with --features archive".to_string(),
+                );
+            }
+        }
        return Ok(0.0);
    }

    let project_name = get_config_str(&config, "package.name");
    let project_version = get_config_str(&config, "package.version");

-    let targets_to_build: Vec<Option<String>> = if let Some(t) = target {
-        vec![Some(normalize_target_os(t).to_string())]
+    let targets_to_build: Vec<(Option<String>, bool)> = if let Some(t) = target {
+        let normalized = normalize_target_os(t);
+        if normalized.is_empty() {
+            vec![(Some(default_target_triple()), true)]
+        } else {
+            vec![(Some(normalized.to_string()), true)]
+        }
    } else {
        let config_targets = get_targets(&config, profile)?;
        if config_targets.is_empty() {
-            vec![None]
+            vec![(Some(default_target_triple()), false)]
        } else {
            config_targets
                .into_iter()
-                .map(|t| Some(normalize_target_os(&t).to_string()))
+                .map(|t| {
+                    let normalized = normalize_target_os(&t);
+                    if normalized.is_empty() {
+                        (Some(default_target_triple()), true)
+                    } else {
+                        (Some(normalized.to_string()), true)
+                    }
+                })
                .collect()
        }
    };

    let start_time = Instant::now();
-    for (i, build_target) in targets_to_build.iter().enumerate() {
+    for (i, (build_target, explicit_target)) in targets_to_build.iter().enumerate() {
        if cancel.load(Ordering::SeqCst) {
            return Err("Build interrupted".to_string());
        }
@@ -211,6 +236,7 @@ fn build_all(
                        &member.path,
                        profile,
                        build_target.as_deref(),
+                        *explicit_target,
                        &[],
                        force,
                        verbose,
@@ -224,6 +250,7 @@ fn build_all(
                    &ws,
                    profile,
                    build_target.as_deref(),
+                    *explicit_target,
                    force,
                    verbose,
                    Some(root),
@@ -236,6 +263,7 @@ fn build_all(
                    root,
                    profile,
                    build_target.as_deref(),
+                    *explicit_target,
                    &excludes,
                    force,
                    verbose,
@@ -249,6 +277,7 @@ fn build_all(
                root,
                profile,
                build_target.as_deref(),
+                *explicit_target,
                &[],
                force,
                verbose,
@@ -263,11 +292,13 @@ fn build_all(
    Ok(elapsed)
 }

+/// Builds each workspace member in order (flat loop, not recursive into nested workspaces).
 #[allow(clippy::too_many_arguments)]
 fn build_workspace(
    workspace: &crate::core::workspace::Workspace,
    profile: &str,
    target: Option<&str>,
+    explicit_target: bool,
    force: bool,
    verbose: bool,
    workspace_root: Option<&Path>,
@@ -279,6 +310,7 @@ fn build_workspace(
            &member.path,
            profile,
            target,
+            explicit_target,
            &[],
            force,
            verbose,
@@ -290,11 +322,13 @@ fn build_workspace(
    Ok(())
 }

+/// Builds a single project at the given root, handling configuration and steps.
 #[allow(clippy::too_many_arguments)]
 fn build_project_at(
    project_root: &Path,
    profile: &str,
    target: Option<&str>,
+    explicit_target: bool,
    exclude_dirs: &[std::path::PathBuf],
    force: bool,
    verbose: bool,
@@ -329,12 +363,43 @@ fn build_project_at(
    }
    let project_name = get_config_str(&config, "package.name");
    let project_version = get_config_str(&config, "package.version");
+    let host_target = default_target_triple();
    let build_target_config = get_build_string_with_profile(&config, "target", profile);
-    let build_target = target.or(if build_target_config.is_empty() {
-        None
-    } else {
-        Some(build_target_config.as_str())
-    });
+    let has_explicit_target = explicit_target || !build_target_config.is_empty();
+    let explicit_build_target = explicit_target
+        .then_some(target)
+        .flatten()
+        .filter(|t| !t.trim().is_empty())
+        .map(|t| {
+            let normalized = normalize_target_os(t);
+            if normalized.is_empty() {
+                host_target.clone()
+            } else {
+                normalized.to_string()
+            }
+        });
+    let configured_build_target = || {
+        if build_target_config.is_empty() {
+            None
+        } else {
+            let normalized = normalize_target_os(&build_target_config);
+            if normalized.is_empty() {
+                None
+            } else {
+                Some(normalized.to_string())
+            }
+        }
+    };
+    let implicit_build_target = || {
+        target
+            .filter(|t| !t.trim().is_empty())
+            .map(|t| normalize_target_os(t).to_string())
+    };
+    let build_target_owned = explicit_build_target
+        .or_else(configured_build_target)
+        .or_else(implicit_build_target)
+        .unwrap_or(host_target);
+    let build_target = Some(build_target_owned.as_str());
    let build_language = get_language_with_profile(&config, profile)?;
    let build_qt = get_bool_with_profile(&config, "qt", profile, false);
    let lang_key = primary_language(&build_language);
@@ -478,68 +543,14 @@ fn build_project_at(
    let resolved_archiver = resolve_tool("DCR_AR", tc_ar.as_deref());

    let out_dir_config = get_build_string_with_profile(&config, "out_dir", profile);
-    let target_dir_binding = if !out_dir_config.is_empty() {
-        let p = Path::new(&out_dir_config);
-        if p.is_absolute() {
-            out_dir_config
-        } else {
-            project_root.join(p).to_string_lossy().to_string()
-        }
-    } else {
-        match workspace_root {
-            Some(root) => {
-                let target_str = build_target
-                    .map(normalize_target_os)
-                    .filter(|t| !t.is_empty());
-                let rel: PathBuf = match target_str {
-                    Some(ref t) => Path::new("target").join(t).join(profile),
-                    None => {
-                        let default_dir = if cfg!(target_os = "linux") {
-                            let arch = std::env::consts::ARCH;
-                            format!("{arch}-unknown-linux-gnu/{profile}")
-                        } else if cfg!(any(
-                            target_os = "freebsd",
-                            target_os = "openbsd",
-                            target_os = "netbsd",
-                            target_os = "dragonfly"
-                        )) {
-                            let arch = std::env::consts::ARCH;
-                            let os = std::env::consts::OS;
-                            format!("{arch}-unknown-{os}/{profile}")
-                        } else {
-                            profile.to_string()
-                        };
-                        Path::new("target").join(&default_dir)
-                    }
-                };
-                root.join(&rel).to_string_lossy().to_string()
-            }
-            None => {
-                let base_dir =
-                    if let Some(rel) = normalize_target(build_target.unwrap_or(""), profile) {
-                        PathBuf::from(rel)
-                    } else {
-                        let default_dir = if cfg!(target_os = "linux") {
-                            let arch = std::env::consts::ARCH;
-                            format!("{arch}-unknown-linux-gnu/{profile}")
-                        } else if cfg!(any(
-                            target_os = "freebsd",
-                            target_os = "openbsd",
-                            target_os = "netbsd",
-                            target_os = "dragonfly"
-                        )) {
-                            let arch = std::env::consts::ARCH;
-                            let os = std::env::consts::OS;
-                            format!("{arch}-unknown-{os}/{profile}")
-                        } else {
-                            profile.to_string()
-                        };
-                        Path::new("target").join(&default_dir)
-                    };
-                project_root.join(base_dir).to_string_lossy().to_string()
-            }
-        }
-    };
+    let target_dir_binding = resolve_artifact_target_dir(
+        project_root,
+        workspace_root,
+        profile,
+        &build_target_owned,
+        &out_dir_config,
+        has_explicit_target,
+    );
    let target_dir = if target_dir_binding.is_empty() {
        None
    } else {
@@ -597,24 +608,9 @@ fn build_project_at(
                        let target_str = build_target
                            .map(normalize_target_os)
                            .filter(|t| !t.is_empty());
-                        let default_dir = if cfg!(target_os = "linux") {
-                            let arch = std::env::consts::ARCH;
-                            format!("{arch}-unknown-linux-gnu/{profile}")
-                        } else if cfg!(any(
-                            target_os = "freebsd",
-                            target_os = "openbsd",
-                            target_os = "netbsd",
-                            target_os = "dragonfly"
-                        )) {
-                            let arch = std::env::consts::ARCH;
-                            let os = std::env::consts::OS;
-                            format!("{arch}-unknown-{os}/{profile}")
-                        } else {
-                            profile.to_string()
-                        };
                        let rel = match target_str {
                            Some(ref t) => Path::new("target").join(t).join(profile),
-                            None => Path::new("target").join(&default_dir),
+                            None => crate::utils::build::native_host_target_rel(profile),
                        };
                        let dep_build_lib1 = dep_member.path.join(&rel);
                        let dep_build_lib2 = wroot.join(&rel);
@@ -679,6 +675,7 @@ fn build_project_at(
                        &dep_root,
                        profile,
                        build_target,
+                        has_explicit_target,
                        &[],
                        force,
                        verbose,
@@ -774,10 +771,12 @@ fn build_project_at(
    let resolved_cflags: Vec<String> = resolved_cflags
        .iter()
        .map(|f| substitute_vars(f, &version_info, profile, &project_name))
+        .map(|f| absolutize_flag_path(&f, project_root, &["-isystem", "-idirafter", "-I", "-i"]))
        .collect();
    let modified_ldflags: Vec<String> = resolved_ldflags
        .iter()
        .map(|f| substitute_vars(f, &version_info, profile, &project_name))
+        .map(|f| absolutize_flag_path(&f, project_root, &["-L", "-T"]))
        .collect();
    let merged_include_dirs: Vec<String> = merged_include_dirs
        .iter()
@@ -843,7 +842,10 @@ fn build_project_at(
        version_suffix: &version_info.suffix,
        version_suffix_dash: &version_info.suffix_dash,
    };
-    let steps_dirty = build_steps_need_run(&build_steps, &step_vars)?;
+    let mut steps_dirty = build_steps_need_run(&build_steps, &step_vars)?;
+    if force {
+        steps_dirty = true;
+    }
    if steps_dirty {
        clean_generated_files(&build_generated)?;
        run_build_steps(
@@ -870,11 +872,11 @@ fn build_project_at(
    if skip && !debug_enabled {
        return Ok(());
    }
-    rep.on_event(BuildEvent::Compiling {
-        name: &project_name,
-        version: &project_version,
-    });
    if !skip {
+        rep.on_event(BuildEvent::Compiling {
+            name: &project_name,
+            version: &project_version,
+        });
        run_compile(&ctx, cancel, rep)?;
        if cancel.load(Ordering::SeqCst) {
            return Err("Build interrupted".to_string());
@@ -884,7 +886,10 @@ fn build_project_at(
    if ctx.package_type == Some("lib") || ctx.kind == "staticlib" || ctx.kind == "sharedlib" {
        package_library(&ctx, &headers, project_root)?;
    }
-    let post_steps_dirty = build_steps_need_run(&build_post_steps, &step_vars)?;
+    let mut post_steps_dirty = build_steps_need_run(&build_post_steps, &step_vars)?;
+    if force {
+        post_steps_dirty = true;
+    }
    if post_steps_dirty {
        run_build_steps(
            &build_post_steps,
@@ -896,8 +901,46 @@ fn build_project_at(
        )?;
    }
    verify_expectations(&build_expects, &step_vars)?;
+    if let Some(archive) = &config.typed().archive {
+        let out = archive.output.replace("{profile}", profile);
+        rep.on_event(BuildEvent::Packing { path: &out });
+        #[cfg(feature = "archive")]
+        {
+            super::archive::pack_archive(project_root, archive, profile)?;
+        }
+        #[cfg(not(feature = "archive"))]
+        {
+            let _ = (project_root, archive, profile, out);
+            return Err(
+                "disk image packing requires building dcr with --features archive".to_string(),
+            );
+        }
+    }
    Ok(())
 }
+
+/// Converts relative paths in flags to absolute paths based on project root for include and link flags.
+fn absolutize_flag_path(flag: &str, project_root: &Path, prefixes: &[&str]) -> String {
+    for prefix in prefixes {
+        if let Some(rest) = flag.strip_prefix(prefix) {
+            if rest.is_empty() {
+                return flag.to_string();
+            }
+            if rest.starts_with('/') || rest.starts_with('@') {
+                return flag.to_string();
+            }
+            if rest.len() >= 2 && rest.as_bytes()[1] == b':' {
+                return flag.to_string();
+            }
+            let abs = project_root.join(rest);
+            let path = abs.to_string_lossy().replace('\\', "/");
+            return format!("{prefix}{path}");
+        }
+    }
+    flag.to_string()
+}
+
+/// Finds the nearest ancestor directory named "target" starting from the given dir.
 fn find_target_root(dir: &str, fallback: &Path) -> PathBuf {
    let p = Path::new(dir);
    for ancestor in p.ancestors() {
@@ -908,6 +951,7 @@ fn find_target_root(dir: &str, fallback: &Path) -> PathBuf {
    fallback.to_path_buf()
 }

+/// Packages the built library by copying headers and libs to the target include and lib directories.
 fn package_library(
    ctx: &BuildContext,
    headers: &[PathBuf],
@@ -962,12 +1006,14 @@ fn package_library(
    Ok(())
 }

+/// Holds the resolved executable paths for Qt tools.
 pub(crate) struct ToolchainExecs {
    pub(crate) uic: String,
    pub(crate) moc: String,
    pub(crate) rcc: String,
 }

+/// Resolves the paths for uic, moc, and rcc tools, preferring configured values or pkg-config/Qt6 variants.
 fn resolve_toolchain_execs(
    uic: &Option<String>,
    moc: &Option<String>,
@@ -982,6 +1028,7 @@ fn resolve_toolchain_execs(
    }
 }

+/// Resolves a Qt tool path, falling back to Qt6 variants if not found in standard locations.
 fn resolve_qt_tool(configured: &Option<String>, qt_bins: Option<&Path>, tool: &str) -> String {
    if let Some(value) = configured {
        return value.clone();
@@ -1004,6 +1051,7 @@ fn resolve_qt_tool(configured: &Option<String>, qt_bins: Option<&Path>, tool: &s
    tool.to_string()
 }

+/// Queries pkg-config for Qt6 host bin directories for the given packages.
 fn resolve_qt_host_bins(pkgs: &[String]) -> Option<PathBuf> {
    let qt_pkgs: Vec<&String> = pkgs.iter().filter(|p| p.starts_with("Qt6")).collect();
    if qt_pkgs.is_empty() {
@@ -1039,6 +1087,7 @@ fn resolve_qt_host_bins(pkgs: &[String]) -> Option<PathBuf> {
    None
 }

+/// Executes pkg-config to get a variable value for a package and returns the path if valid.
 fn query_pkg_config_var(pkg: &str, var: &str) -> Option<PathBuf> {
    let output = std::process::Command::new("pkg-config")
        .arg(format!("--variable={var}"))
@@ -1056,6 +1105,7 @@ fn query_pkg_config_var(pkg: &str, var: &str) -> Option<PathBuf> {
    if path.is_dir() { Some(path) } else { None }
 }

+/// Extracts tool binaries from a libexec directory or its bin subdirectory.
 fn qt_bins_from_libexec(libexec: &Path) -> Option<PathBuf> {
    for tool in ["moc", "uic", "rcc"] {
        if libexec.join(tool).is_file() {
@@ -1069,12 +1119,14 @@ fn qt_bins_from_libexec(libexec: &Path) -> Option<PathBuf> {
    if bin.is_dir() { Some(bin) } else { None }
 }

+/// Detects if a Qt6 tool variant (like uic6 or uic-qt6) is available on the PATH.
 fn detect_qt6_tool_variant(tool: &str) -> Option<String> {
    [format!("{tool}6"), format!("{tool}-qt6")]
        .into_iter()
        .find(|candidate| is_on_path(candidate))
 }

+/// Checks if a command is available either as a file or in the PATH environment variable.
 fn is_on_path(cmd: &str) -> bool {
    if Path::new(cmd).is_file() {
        return true;
@@ -1082,3 +1134,35 @@ fn is_on_path(cmd: &str) -> bool {
    std::env::var_os("PATH")
        .is_some_and(|paths| std::env::split_paths(&paths).any(|dir| dir.join(cmd).is_file()))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::absolutize_flag_path;
+    use std::path::Path;
+
+    #[test]
+    fn absolutize_prefers_long_include_prefixes() {
+        let root = Path::new("/pkg");
+        let prefs = ["-isystem", "-idirafter", "-I", "-i"];
+        assert_eq!(
+            absolutize_flag_path("-isystemvendor/inc", root, &prefs),
+            "-isystem/pkg/vendor/inc"
+        );
+        assert_eq!(
+            absolutize_flag_path("-idiraftervendor/old", root, &prefs),
+            "-idirafter/pkg/vendor/old"
+        );
+        assert_eq!(
+            absolutize_flag_path("-I../inc", root, &prefs),
+            "-I/pkg/../inc"
+        );
+        assert_eq!(
+            absolutize_flag_path("-i../inc", root, &prefs),
+            "-i/pkg/../inc"
+        );
+        assert_eq!(
+            absolutize_flag_path("-I/usr/include", root, &prefs),
+            "-I/usr/include"
+        );
+    }
+}
--- a/src/core/build/language/asm/common.rs
+++ b/src/core/build/language/asm/common.rs
@@ -1,9 +1,17 @@
 use crate::core::build::builder::BuildContext;
 use crate::core::build::builder::artifact;
 use crate::core::build::common;
+use crate::utils::build::{is_compile_only, is_flat_bin};
 use std::path::Path;
 use std::time::Instant;

+/// Keeps only assembler-relevant flags from a cflags list.
+///
+/// # Parameters
+/// - `flags`: Full compiler flag list (often shared with C/C++).
+///
+/// # Returns
+/// Cloned flags that start with `-I`/`-i` or equal `-g`.
 pub fn filter_asm_flags(flags: &[String]) -> Vec<String> {
    flags
        .iter()
@@ -15,6 +23,19 @@ pub fn filter_asm_flags(flags: &[String]) -> Vec<String> {
        .collect()
 }

+/// Builds assembly sources with direct flat emission when `kind` is `flat-bin`.
+///
+/// For non-flat kinds, assembles to objects and then links/archives as usual.
+///
+/// # Parameters
+/// - `ctx`: Build context (kind, sources, flags, …).
+/// - `backend_name`: Label used in error messages (e.g. `"NASM"`).
+/// - `default_assembler`: Assembler binary when `ctx.compiler` is empty.
+/// - `extensions`: Source extensions to collect.
+/// - `build_object`: Per-source assemble callback `(assembler, src, out, ctx)`.
+///
+/// # Returns
+/// Elapsed seconds, or an error string.
 pub fn build_assembly<F>(
    ctx: &BuildContext,
    backend_name: &str,
@@ -22,13 +43,75 @@ pub fn build_assembly<F>(
    extensions: &[&str],
    build_object: F,
 ) -> Result<f64, String>
+where
+    F: Fn(&str, &str, &str, &BuildContext) -> Result<(), String> + Sync,
+{
+    build_assembly_with_mode(
+        ctx,
+        backend_name,
+        default_assembler,
+        extensions,
+        FlatEmit::Direct,
+        build_object,
+    )
+}
+
+/// Builds assembly sources; for `flat-bin`, assembles to objects then runs objcopy.
+///
+/// For non-flat kinds, assembles to objects and then links/archives as usual.
+///
+/// # Parameters
+/// - Same as [`build_assembly`]; only the flat emission strategy differs.
+///
+/// # Returns
+/// Elapsed seconds, or an error string.
+pub fn build_assembly_via_objcopy<F>(
+    ctx: &BuildContext,
+    backend_name: &str,
+    default_assembler: &str,
+    extensions: &[&str],
+    build_object: F,
+) -> Result<f64, String>
+where
+    F: Fn(&str, &str, &str, &BuildContext) -> Result<(), String> + Sync,
+{
+    build_assembly_with_mode(
+        ctx,
+        backend_name,
+        default_assembler,
+        extensions,
+        FlatEmit::ViaObjcopy,
+        build_object,
+    )
+}
+
+/// Flat-bin emission strategy: direct assembler output, or object then objcopy.
+#[derive(Clone, Copy)]
+enum FlatEmit {
+    Direct,
+    ViaObjcopy,
+}
+
+/// Core assembly build with a chosen flat emission mode; `build_object` runs per source in parallel.
+fn build_assembly_with_mode<F>(
+    ctx: &BuildContext,
+    backend_name: &str,
+    default_assembler: &str,
+    extensions: &[&str],
+    flat_mode: FlatEmit,
+    build_object: F,
+) -> Result<f64, String>
 where
    F: Fn(&str, &str, &str, &BuildContext) -> Result<(), String> + Sync,
 {
    let lang = ctx.language.to_lowercase();
-    if lang.split(',').any(|p| p.trim() != "asm") {
+    // Validate language
+    if lang.split(',').any(|p| {
+        let t = p.trim();
+        t != "asm" && t != "llvm_ir" && t != "llvm-ir" && t != "ll"
+    }) {
        return Err(format!(
-            "{backend_name} backend requires build.language = \"asm\""
+            "{backend_name} backend requires build.language = \"asm\" (or llvm_ir for LLC)"
        ));
    }

@@ -45,13 +128,49 @@ where
        ctx.exclude_dirs,
        ctx.include_paths,
    )?;
+
+    let flat = is_flat_bin(ctx.kind);
    let obj_dir = match ctx.target_dir {
        Some(dir) => Path::new(dir).join("obj"),
        None => Path::new("./target").join(ctx.profile).join("obj"),
    };
-    let objects = build_objects_common(assembler, &sources, &obj_dir, ctx, &build_object)?;

-    if ctx.kind == "none" || ctx.kind == "custom" {
+    let objects = match (flat, flat_mode) {
+        // Dispatch based on flat binary kind and emission mode
+        (true, FlatEmit::Direct) => {
+            let outs: Vec<String> = sources
+                .iter()
+                .map(|s| artifact::flat_source_output_path(ctx, s))
+                .collect();
+            common::parallel_build(
+                sources.len(),
+                |i| build_object(assembler, &sources[i], &outs[i], ctx),
+                ctx.codegen_units,
+            )?;
+            outs
+        }
+        (true, FlatEmit::ViaObjcopy) => {
+            let intermediates: Vec<String> = sources
+                .iter()
+                .map(|s| common::object_path(&obj_dir, s, "o"))
+                .collect();
+            common::parallel_build(
+                sources.len(),
+                |i| build_object(assembler, &sources[i], &intermediates[i], ctx),
+                ctx.codegen_units,
+            )?;
+            let mut outs = Vec::with_capacity(sources.len());
+            for (i, src) in sources.iter().enumerate() {
+                let out = artifact::flat_source_output_path(ctx, src);
+                artifact::objcopy_binary(ctx, &intermediates[i], &out)?;
+                outs.push(out);
+            }
+            outs
+        }
+        (false, _) => build_objects_common(assembler, &sources, &obj_dir, ctx, &build_object)?,
+    };
+
+    if is_compile_only(ctx.kind) {
        return Ok(common::elapsed_secs(start_time));
    }

@@ -62,6 +181,7 @@ where
    artifact::link_binary(ctx, &objects, "cc", start_time)
 }

+/// Compiles all sources to objects in parallel (non-flat path) and returns object paths.
 fn build_objects_common<F>(
    assembler: &str,
    sources: &[String],
--- a/src/core/build/language/asm/fasm/mod.rs
+++ b/src/core/build/language/asm/fasm/mod.rs
@@ -5,10 +5,14 @@ use std::fs;
 use std::path::Path;
 use std::process::Command;

+/// Builds an assembly file using the FASM assembler.
+///
+/// Delegates to the shared assembly build logic with FASM configuration.
 pub fn build(ctx: &BuildContext) -> Result<f64, String> {
    asm::build_assembly(ctx, "FASM", "fasm", &["asm", "fasm"], build_object)
 }

+/// Collects all source files for assembly files using FASM.
 pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
    common::collect_sources(
        ctx.source_roots,
@@ -18,6 +22,7 @@ pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String>
    )
 }

+/// Assembles one FASM source into an object file.
 fn build_object(
    assembler: &str,
    source: &str,
@@ -28,6 +33,7 @@ fn build_object(
        fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
    }

+    // Skip rebuilding if the object is up to date
    if !common::needs_rebuild(source, obj_path) {
        return Ok(());
    }
--- a/src/core/build/language/asm/gas/mod.rs
+++ b/src/core/build/language/asm/gas/mod.rs
@@ -22,6 +22,10 @@ use std::fs;
 use std::path::Path;
 use std::process::Command;

+/// Builds GAS (`.s`) sources via the GNU Assembler.
+///
+/// Resolves `as` on PATH and delegates to the shared assembly builder. For
+/// `flat-bin`, intermediates are converted with objcopy after assembly.
 pub fn build(ctx: &BuildContext) -> Result<f64, String> {
    // Use full path to as
    let as_path = std::process::Command::new("which")
@@ -32,9 +36,12 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
        .map(|s| s.trim().to_string())
        .filter(|s| !s.is_empty())
        .unwrap_or_else(|| "as".to_string());
-    asm::build_assembly(ctx, "GAS", &as_path, &["s"], build_object)
+    asm::build_assembly_via_objcopy(ctx, "GAS", &as_path, &["s"], build_object)
 }

+/// Collects assembly source files with .s extension from the build context's source roots.
+///
+/// Excludes specified directories and respects include paths for filtering.
 pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
    common::collect_sources(
        ctx.source_roots,
@@ -44,6 +51,10 @@ pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String>
    )
 }

+/// Assembles a single .s source file into an object file using the provided assembler.
+///
+/// Creates parent directories for the output object, skips if up-to-date,
+/// runs the assembler with flags from the build context, and handles verbose output.
 fn build_object(
    assembler: &str,
    source: &str,
@@ -54,10 +65,12 @@ fn build_object(
        fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
    }

+    // Check if the object file is already up to date to avoid unnecessary rebuilds.
    if !common::needs_rebuild(source, obj_path) {
        return Ok(());
    }

+    // Prepare the assembler command with source file and output path.
    let mut cmd = Command::new(assembler);
    cmd.arg(source).arg("-o").arg(obj_path);

--- a/src/core/build/language/asm/masm/mod.rs
+++ b/src/core/build/language/asm/masm/mod.rs
@@ -5,10 +5,15 @@ use std::fs;
 use std::path::Path;
 use std::process::Command;

+/// Builds MASM (`.asm`) sources via `ml`.
+///
+/// For `flat-bin`, intermediates are converted with objcopy after assembly.
+/// Returns elapsed seconds or an error.
 pub fn build(ctx: &BuildContext) -> Result<f64, String> {
-    asm::build_assembly(ctx, "MASM", "ml", &["asm"], build_object)
+    asm::build_assembly_via_objcopy(ctx, "MASM", "ml", &["asm"], build_object)
 }

+/// Collects MASM assembly source files from the given source roots.
 pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
    common::collect_sources(
        ctx.source_roots,
@@ -18,6 +23,12 @@ pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String>
    )
 }

+/// Builds a single MASM object file from the given source.
+///
+/// Creates the parent directory for the output object if it doesn't exist,
+/// skips the build if the object is already up to date, constructs the ml
+/// command line with flags, prints the command in debug mode if enabled,
+/// and executes it.
 fn build_object(
    assembler: &str,
    source: &str,
@@ -25,10 +36,12 @@ fn build_object(
    ctx: &BuildContext,
 ) -> Result<(), String> {
    if let Some(parent) = Path::new(obj_path).parent() {
+        // Ensure the parent directory exists for the object file
        fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
    }

    if !common::needs_rebuild(source, obj_path) {
+        // Skip rebuild if the object file is already current
        return Ok(());
    }

@@ -40,6 +53,7 @@ fn build_object(
        .arg(source);

    for flag in crate::core::build::language::asm::common::filter_asm_flags(ctx.cflags) {
+        // Add filtered compiler flags to the command
        cmd.arg(flag);
    }

--- a/src/core/build/language/asm/mod.rs
+++ b/src/core/build/language/asm/mod.rs
@@ -15,6 +15,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.

+/// Assembly language module for the DCR build system.
 pub mod common;
 pub mod fasm;
 pub mod gas;
@@ -23,15 +24,21 @@ pub mod nasm;

 use crate::core::build::language::Language;

+/// Represents the assembly language support in the build system.
 pub struct Asm;

 impl Language for Asm {
+    /// Returns the identifier string for this language.
    fn id(&self) -> &'static str {
        "asm"
    }
+
+    /// Returns the list of supported file extensions for assembly files.
    fn extensions(&self) -> &'static [&'static str] {
        &["s", "S", "asm"]
    }
+
+    /// Checks whether the given token matches the assembly language, using case-insensitive comparison.
    fn matches_token(&self, token: &str) -> bool {
        token.eq_ignore_ascii_case("asm")
    }
--- a/src/core/build/language/asm/nasm/mod.rs
+++ b/src/core/build/language/asm/nasm/mod.rs
@@ -15,6 +15,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.

+/// Support for NASM assembly language in the DCR build system.
 use crate::core::build::builder::BuildContext;
 use crate::core::build::common;
 use crate::core::build::language::asm::common as asm;
@@ -22,10 +23,16 @@ use std::fs;
 use std::path::Path;
 use std::process::Command;

+/// Builds assembly sources using the NASM assembler.
+///
+/// Delegates to the shared assembly builder with NASM-specific configuration.
 pub fn build(ctx: &BuildContext) -> Result<f64, String> {
    asm::build_assembly(ctx, "NASM", "nasm", &["asm"], build_object)
 }

+/// Collects source files for NASM assembly.
+///
+/// Filters for .asm files only, as NASM uses that extension (distinct from GAS .s).
 pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
    // NASM handles .asm only (not .s which is GAS syntax, not .S which is GCC preprocessed)
    common::collect_sources(
@@ -36,6 +43,9 @@ pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String>
    )
 }

+/// Builds a single object file from an assembly source using NASM.
+///
+/// Handles directory creation, rebuild checks, format selection, and command execution.
 fn build_object(
    assembler: &str,
    source: &str,
@@ -43,14 +53,21 @@ fn build_object(
    ctx: &BuildContext,
 ) -> Result<(), String> {
    if let Some(parent) = Path::new(obj_path).parent() {
+        // Ensure output directory exists before building.
        fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
    }

+    // Skip building if the object is already up to date.
    if !common::needs_rebuild(source, obj_path) {
        return Ok(());
    }

-    let format = nasm_format(ctx.platform);
+    // Select appropriate object format for the target platform and binary type.
+    let format = if crate::utils::build::is_flat_bin(ctx.kind) {
+        "bin"
+    } else {
+        nasm_format(ctx.platform)
+    };

    let mut cmd = Command::new(assembler);
    cmd.arg("-f")
@@ -59,6 +76,7 @@ fn build_object(
        .arg("-o")
        .arg(obj_path);

+    // Append any additional assembly flags from build context.
    for flag in crate::core::build::language::asm::common::filter_asm_flags(ctx.cflags) {
        cmd.arg(flag);
    }
@@ -70,6 +88,9 @@ fn build_object(
    common::run_command_sync_output(&mut cmd)
 }

+/// Selects the NASM object file format string based on the target platform.
+///
+/// Supports different formats for x86 on various OSes and architectures.
 fn nasm_format(platform: Option<&str>) -> &'static str {
    if let Some(p) = platform {
        let p = p.to_lowercase().replace('-', "_");
--- a/src/core/build/language/c/mod.rs
+++ b/src/core/build/language/c/mod.rs
@@ -17,15 +17,21 @@

 use crate::core::build::language::Language;

+/// Represents the C programming language support within the DCR build system.
 pub struct C;

 impl Language for C {
+    /// Returns the unique identifier for the C language.
    fn id(&self) -> &'static str {
        "c"
    }
+
+    /// Returns an array containing the file extension associated with C source code.
    fn extensions(&self) -> &'static [&'static str] {
        &["c"]
    }
+
+    /// Checks whether the given token matches the C language identifier in a case-insensitive manner.
    fn matches_token(&self, token: &str) -> bool {
        token.eq_ignore_ascii_case("c")
    }
--- a/src/core/build/language/cxx/mod.rs
+++ b/src/core/build/language/cxx/mod.rs
@@ -15,20 +15,26 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.

+/// C++ language support for the DCR build system.
 pub mod qt;

 use crate::core::build::language::Language;

 pub struct Cxx;

+/// C++ language implementation.
 impl Language for Cxx {
+    /// Returns the language ID "cxx".
    fn id(&self) -> &'static str {
        "cxx"
    }
+    /// Returns the extensions for C++ files.
    fn extensions(&self) -> &'static [&'static str] {
        &["cpp", "cxx", "cc"]
    }
+    /// Checks if the token matches C++ language names, ignoring case.
    fn matches_token(&self, token: &str) -> bool {
+        // Case-insensitive comparison using to_lowercase
        matches!(token.to_lowercase().as_str(), "c++" | "cpp" | "cxx")
    }
 }
--- a/src/core/build/language/cxx/qt.rs
+++ b/src/core/build/language/cxx/qt.rs
@@ -22,6 +22,16 @@ use std::fs;
 use std::path::{Path, PathBuf};
 use std::process::Command;

+/// Runs uic/rcc/moc on Qt UI, resource, and header sources under `build_dir/qt`.
+///
+/// # Parameters
+/// - `ctx`: Sources, excludes, and toolchain tool paths.
+/// - `build_dir`: Directory that will contain the generated `qt/` tree.
+///
+/// # Returns
+/// - `Ok(Some(qt_dir))` if any generated files were produced.
+/// - `Ok(None)` if there was nothing to process.
+/// - `Err` if a Qt tool fails.
 pub fn process_qt(ctx: &BuildContext, build_dir: &Path) -> Result<Option<PathBuf>, String> {
    let qt_dir = build_dir.join("qt");
    fs::create_dir_all(&qt_dir).map_err(|e| format!("Failed to create qt dir: {e}"))?;
@@ -37,6 +47,7 @@ pub fn process_qt(ctx: &BuildContext, build_dir: &Path) -> Result<Option<PathBuf
    let mut qt_moc_args = Vec::new();
    let qt_modules = vec!["Qt6Core", "Qt6Widgets", "Qt6Gui", "Qt6Svg"];

+    // Collect -I and -D flags from pkg-config for Qt modules to use in moc invocations
    for module in qt_modules {
        if let Ok(cflags) = run_pkg_config(module, "--cflags") {
            for flag in cflags.split_whitespace() {
@@ -123,6 +134,7 @@ pub fn process_qt(ctx: &BuildContext, build_dir: &Path) -> Result<Option<PathBuf
    }
 }

+/// Executes the specified command with the given arguments and returns success or an error message.
 fn run_command(cmd_path: &str, args: &[&str], verbose: bool) -> Result<(), String> {
    let mut cmd = Command::new(cmd_path);
    cmd.args(args);
--- a/src/core/build/language/llvm_ir/mod.rs
+++ b/src/core/build/language/llvm_ir/mod.rs
@@ -6,24 +6,32 @@ use std::fs;
 use std::path::Path;
 use std::process::Command;

+/// Represents the LLVM IR language implementation for the build system.
 pub struct LlvmIr;

 impl Language for LlvmIr {
+    /// Returns the unique identifier for the LLVM IR language.
    fn id(&self) -> &'static str {
        "llvm_ir"
    }
+
+    /// Returns the list of file extensions recognized for this language.
    fn extensions(&self) -> &'static [&'static str] {
        &["ll"]
    }
+
+    /// Determines whether the provided token matches the LLVM IR language.
    fn matches_token(&self, token: &str) -> bool {
        matches!(token.to_lowercase().as_str(), "llvm_ir" | "llvm-ir" | "ll")
    }
 }

+/// Builds LLVM IR source files into object files using llc.
 pub fn build(ctx: &BuildContext) -> Result<f64, String> {
-    asm::build_assembly(ctx, "LLVM-IR", "llc", &["ll"], build_object)
+    asm::build_assembly_via_objcopy(ctx, "LLVM-IR", "llc", &["ll"], build_object)
 }

+/// Collects source files for LLVM IR compilation from the given context.
 pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
    common::collect_sources(
        ctx.source_roots,
@@ -33,6 +41,7 @@ pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String>
    )
 }

+/// Builds a single LLVM IR source file into an object file.
 fn build_object(
    assembler: &str,
    source: &str,
@@ -40,6 +49,7 @@ fn build_object(
    ctx: &BuildContext,
 ) -> Result<(), String> {
    if let Some(parent) = Path::new(obj_path).parent() {
+        // Create parent directory if it does not exist
        fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
    }

--- a/src/core/build/language/mod.rs
+++ b/src/core/build/language/mod.rs
@@ -15,21 +15,29 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.

+/// Core module for language support in the DCR build system.
+/// Defines the Language trait and helper functions to register and lookup languages.
 pub mod asm;
 pub mod c;
 pub mod cxx;
 pub mod llvm_ir;

+/// Trait representing a supported programming language.
+/// Each implementation must specify its unique identifier, list of supported file extensions,
+/// and a method to determine if a given token matches the language.
 pub trait Language {
    fn id(&self) -> &'static str;
    fn extensions(&self) -> &'static [&'static str];
    fn matches_token(&self, token: &str) -> bool;
 }

+/// Returns a fixed-size array containing static references to all supported language types.
 pub fn languages() -> [&'static dyn Language; 4] {
    [&c::C, &cxx::Cxx, &asm::Asm, &llvm_ir::LlvmIr]
 }

+/// Looks up the language implementation that matches the given token by checking each language's
+/// matches_token method. Returns the first match or None if no language matches.
 pub fn language_for_token(token: &str) -> Option<&'static dyn Language> {
    languages().into_iter().find(|l| l.matches_token(token))
 }
@@ -38,6 +46,7 @@ pub fn language_for_token(token: &str) -> Option<&'static dyn Language> {
 mod tests {
    use super::*;

+    /// Ensures that input tokens are resolved to the correct language IDs.
    #[test]
    fn tokens_resolve_to_languages() {
        assert_eq!(language_for_token("c").unwrap().id(), "c");
@@ -48,6 +57,7 @@ mod tests {
        assert!(language_for_token("rust").is_none());
    }

+    /// Ensures that each language reports the expected set of file extensions.
    #[test]
    fn languages_expose_expected_extensions() {
        assert_eq!(c::C.extensions(), &["c"]);
--- a/src/core/build/mod.rs
+++ b/src/core/build/mod.rs
@@ -15,6 +15,11 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.

+/// Core build module for DCR — a Cargo-like C/C++ project manager.
+/// This module defines the build engine and re-exports key components for
+/// building C/C++ projects.
+#[cfg(feature = "archive")]
+pub mod archive;
 pub mod builder;
 pub mod cache;
 pub mod common;
--- a/src/core/build/report.rs
+++ b/src/core/build/report.rs
@@ -21,6 +21,7 @@

 use std::sync::{Arc, atomic::AtomicBool};

+/// Represents a build request with options for the build process, including profile selection, target specification, force flag, verbosity, workspace, and a cancellation signal.
 pub struct BuildRequest {
    pub profile: String,
    pub target: Option<String>,
@@ -30,21 +31,25 @@ pub struct BuildRequest {
    pub cancel: Arc<AtomicBool>,
 }

+/// Contains the result of a build operation, specifically the duration in seconds.
 #[allow(dead_code)]
 pub struct BuildOutcome {
    pub secs: f64,
 }

+/// Wraps a string message as a build error.
 pub struct BuildError {
    pub message: String,
 }

+/// Creates a BuildError from a String message.
 impl From<String> for BuildError {
    fn from(message: String) -> Self {
        BuildError { message }
    }
 }

+/// Represents events that the build engine can emit during compilation and packaging.
 pub enum BuildEvent<'a> {
    TargetStart {
        index: usize,
@@ -69,6 +74,9 @@ pub enum BuildEvent<'a> {
        name: &'a str,
        version: &'a str,
    },
+    Packing {
+        path: &'a str,
+    },
    CompilerOutput {
        stream: &'a str,
        text: &'a str,
@@ -78,6 +86,8 @@ pub enum BuildEvent<'a> {
    },
 }

+/// Trait for handling build events in different reporting backends.
 pub trait BuildReporter {
+    /// Callback invoked when a build event is generated.
    fn on_event(&mut self, event: BuildEvent<'_>);
 }
--- a/src/core/build/resolve.rs
+++ b/src/core/build/resolve.rs
@@ -18,6 +18,12 @@
 use crate::core::build_config::Config;
 use crate::utils::build::{get_config_str, normalize_target_os, profile_table};

+/// Retrieves a raw TOML value from the config using a prioritized lookup order based on target, profile, and base sections.
+///
+/// The keys are checked in this order:
+/// {section}.{target}.{profile}.{field}, {section}.{profile}.{target}.{field}, {section}.{target}.{field}, {section}.{profile}.{field}, {section}.{field}
+///
+/// Returns the value if found, otherwise None.
 pub(crate) fn get_config_value_raw(
    config: &Config,
    section: &str,
@@ -57,6 +63,9 @@ pub(crate) fn get_config_value_raw(
    None
 }

+/// Checks if the 'inherit' flag is enabled for the given section, profile, and target.
+///
+/// Returns true by default if the flag is not set.
 pub(crate) fn get_inherit(
    config: &Config,
    section: &str,
@@ -68,6 +77,9 @@ pub(crate) fn get_inherit(
        .unwrap_or(true)
 }

+/// Extracts a trimmed non-empty string value from the config.
+///
+/// Returns Some(value) if found, None otherwise.
 pub(crate) fn get_config_value(
    config: &Config,
    section: &str,
@@ -80,6 +92,9 @@ pub(crate) fn get_config_value(
        .filter(|s| !s.is_empty())
 }

+/// Fetches a string value from the build section, inheriting from base if enabled.
+///
+/// Returns the value or default empty string if not inheriting.
 pub(crate) fn get_string_with_profile_and_target(
    config: &Config,
    field: &str,
@@ -94,10 +109,12 @@ pub(crate) fn get_string_with_profile_and_target(
    }
 }

+/// Gets a build string value for the given profile without a target.
 pub fn get_build_string_with_profile(config: &Config, field: &str, profile: &str) -> String {
    get_string_with_profile_and_target(config, field, profile, None)
 }

+/// Gets a string value from the language-specific build.{lang} section.
 pub(crate) fn get_lang_string(
    config: &Config,
    lang: &str,
@@ -108,6 +125,7 @@ pub(crate) fn get_lang_string(
    get_config_value(config, &format!("build.{lang}"), field, profile, target)
 }

+/// Gets a list of strings from the language-specific build.{lang} section.
 pub(crate) fn get_lang_list(
    config: &Config,
    lang: &str,
@@ -121,6 +139,7 @@ pub(crate) fn get_lang_list(
    }
 }

+/// Parses a TOML array into a Vec<String>, erroring if not an array of strings.
 pub(crate) fn parse_string_array(value: &toml::Value, key: &str) -> Result<Vec<String>, String> {
    let arr = value
        .as_array()
@@ -135,6 +154,9 @@ pub(crate) fn parse_string_array(value: &toml::Value, key: &str) -> Result<Vec<S
    Ok(out)
 }

+/// Collects a list of strings from config, supporting inheritance from base and profile/target overrides.
+///
+/// If inherit is true, starts with the base list and appends custom entries if defined.
 pub(crate) fn get_list_with_profile_and_target(
    config: &Config,
    field: &str,
@@ -154,6 +176,7 @@ pub(crate) fn get_list_with_profile_and_target(
                    .get(&format!("build.{field}"))
                    .map(|v| v == &val)
                    .unwrap_or(false);
+            // Skip re-adding the base list when this is the base definition to prevent duplication
            if !is_base {
                let custom = parse_string_array(&val, &format!("build.{field}"))?;
                if inherit {
@@ -184,6 +207,7 @@ pub(crate) fn get_list_with_profile_and_target(
    Ok(out)
 }

+/// Gets the list of strings for the given profile without a target.
 pub(crate) fn get_list_with_profile(
    config: &Config,
    field: &str,
@@ -192,10 +216,21 @@ pub(crate) fn get_list_with_profile(
    get_list_with_profile_and_target(config, field, profile, None)
 }

+/// Returns the list of targets for the given profile.
 pub(crate) fn get_targets(config: &Config, profile: &str) -> Result<Vec<String>, String> {
    get_list_with_profile(config, "targets", profile)
 }

+/// Parses the config value as a list of strings.
+///
+/// # Parameters
+/// - `config`: Project config.
+/// - `key`: Dot-path key (e.g. `build.sources`).
+///
+/// # Returns
+/// - `Ok([])` if the key is missing.
+/// - `Ok(vec)` for an array of strings.
+/// - `Err` if present but not an array of strings.
 pub(crate) fn get_config_list(config: &Config, key: &str) -> Result<Vec<String>, String> {
    let value = match config.get(key) {
        Some(v) => v,
--- a/src/core/build/steps.rs
+++ b/src/core/build/steps.rs
@@ -30,6 +30,7 @@ pub(crate) struct BuildStep {
    cmd: String,
 }

+/// Holds interpolated version and profile strings for build step substitution.
 pub(crate) struct StepVars<'a> {
    pub(crate) profile: &'a str,
    pub(crate) version: &'a str,
@@ -40,6 +41,7 @@ pub(crate) struct StepVars<'a> {
    pub(crate) version_suffix_dash: &'a str,
 }

+/// Parses TOML array of build step tables into Vec<BuildStep>.
 fn get_build_steps_from_value(value: &toml::Value, key: &str) -> Result<Vec<BuildStep>, String> {
    let arr = value
        .as_array()
@@ -86,6 +88,7 @@ fn get_build_steps_from_value(value: &toml::Value, key: &str) -> Result<Vec<Buil
    Ok(out)
 }

+/// Retrieves build steps for a specific profile from config, falling back to default if not present.
 pub(crate) fn get_build_steps_with_profile(
    config: &Config,
    field: &str,
@@ -99,6 +102,7 @@ pub(crate) fn get_build_steps_with_profile(
    get_build_steps(config, &format!("build.{field}"))
 }

+/// Gets build steps from config for the given key.
 fn get_build_steps(config: &Config, key: &str) -> Result<Vec<BuildStep>, String> {
    let value = match config.get(key) {
        Some(v) => v,
@@ -110,6 +114,7 @@ fn get_build_steps(config: &Config, key: &str) -> Result<Vec<BuildStep>, String>
 use crate::core::build::report::{BuildEvent, BuildReporter};
 use std::sync::{Arc, atomic::AtomicBool};

+/// Runs all build steps in sequence, checking for cancellation and reporting progress.
 pub(crate) fn run_build_steps(
    steps: &[BuildStep],
    tools: &ToolchainExecs,
@@ -127,6 +132,7 @@ pub(crate) fn run_build_steps(
    Ok(())
 }

+/// Executes a single build step, handling glob expansion, output paths, and command substitution.
 fn run_build_step(
    step: &BuildStep,
    tools: &ToolchainExecs,
@@ -137,6 +143,7 @@ fn run_build_step(
 ) -> Result<(), String> {
    let input_pattern = expand_step_value(&step.input, "", vars);
    let inputs = expand_glob(&input_pattern)?;
+    // Skip step if no matching input files found
    if inputs.is_empty() {
        return Ok(());
    }
@@ -170,6 +177,7 @@ fn run_build_step(
    Ok(())
 }

+/// Deletes files (not directories) matching the given glob patterns.
 pub(crate) fn clean_generated_files(patterns: &[String]) -> Result<(), String> {
    for pattern in patterns {
        for path in expand_glob(pattern)? {
@@ -181,6 +189,7 @@ pub(crate) fn clean_generated_files(patterns: &[String]) -> Result<(), String> {
    Ok(())
 }

+/// Expands glob patterns to find matching files.
 pub(crate) fn expand_glob(pattern: &str) -> Result<Vec<PathBuf>, String> {
    let mut out = Vec::new();
    let entries = glob(pattern).map_err(|err| format!("glob error: {err}"))?;
@@ -191,6 +200,7 @@ pub(crate) fn expand_glob(pattern: &str) -> Result<Vec<PathBuf>, String> {
    Ok(out)
 }

+/// Verifies that expected artifacts are present by expanding patterns.
 pub(crate) fn verify_expectations(patterns: &[String], vars: &StepVars) -> Result<(), String> {
    for pattern in patterns {
        let expanded = expand_step_value(pattern, "", vars);
@@ -202,6 +212,7 @@ pub(crate) fn verify_expectations(patterns: &[String], vars: &StepVars) -> Resul
    Ok(())
 }

+/// True if the step should run: missing/unreadable output, unreadable input, or input newer than output.
 fn should_run_step(input: &Path, output: &Path) -> bool {
    let in_time = fs::metadata(input).and_then(|m| m.modified());
    let out_time = fs::metadata(output).and_then(|m| m.modified());
@@ -212,6 +223,7 @@ fn should_run_step(input: &Path, output: &Path) -> bool {
    }
 }

+/// Substitutes variables into step command template and replaces placeholders.
 fn substitute_step_cmd(
    template: &str,
    input: &Path,
@@ -232,6 +244,7 @@ fn substitute_step_cmd(
        .replace("{stem}", stem)
 }

+/// Builds a list of compiler flags from cflags, include dirs, and compiler type.
 pub(crate) fn build_step_flags(
    cflags: &[String],
    include_dirs: &[String],
@@ -264,6 +277,7 @@ pub(crate) fn build_step_flags(
        .join(" ")
 }

+/// Quotes argument if it contains whitespace or double quotes.
 fn quote_step_arg(arg: String) -> String {
    if !arg.chars().any(|c| c.is_whitespace() || c == '"') {
        return arg;
@@ -272,6 +286,7 @@ fn quote_step_arg(arg: String) -> String {
    format!("\"{escaped}\"")
 }

+/// Checks if compiler is MSVC based on name.
 fn is_msvc_compiler(compiler: &str) -> bool {
    let lower = compiler.to_lowercase();
    lower.contains("cl.exe")
@@ -280,6 +295,7 @@ fn is_msvc_compiler(compiler: &str) -> bool {
        || lower.contains("msvc")
 }

+/// Runs shell command with output capture and cancellation support.
 fn run_shell_command(
    cmd: &str,
    cancel: &Arc<AtomicBool>,
@@ -352,6 +368,7 @@ fn run_shell_command(
    Ok(status)
 }

+/// Checks if any build step needs to be run by comparing timestamps.
 pub(crate) fn build_steps_need_run(steps: &[BuildStep], vars: &StepVars) -> Result<bool, String> {
    for step in steps {
        let input_pattern = expand_step_value(&step.input, "", vars);
@@ -380,6 +397,7 @@ pub(crate) fn build_steps_need_run(steps: &[BuildStep], vars: &StepVars) -> Resu
    Ok(false)
 }

+/// Creates VersionInfo from StepVars.
 fn make_version_info(vars: &StepVars) -> VersionInfo {
    VersionInfo {
        full: vars.version.to_string(),
@@ -391,6 +409,7 @@ fn make_version_info(vars: &StepVars) -> VersionInfo {
    }
 }

+/// Expands step value by substituting vars and stem.
 fn expand_step_value(template: &str, stem: &str, vars: &StepVars) -> String {
    let info = make_version_info(vars);
    let s = substitute_vars(template, &info, vars.profile, "");
--- a/src/core/build_config.rs
+++ b/src/core/build_config.rs
@@ -36,8 +36,10 @@ const VALID_KINDS: &[&str] = &[
    "elf",
    "none",
    "custom",
+    "flat-bin",
 ];

+/// Represents errors that can occur during configuration loading, parsing, or validation.
 #[derive(Debug)]
 pub enum ConfigError {
    Io(std::io::Error),
@@ -79,6 +81,7 @@ impl From<toml::ser::Error> for ConfigError {
    }
 }

+/// Core configuration structure that manages TOML parsing, typed views, and validation for DCR projects.
 pub struct Config {
    path: PathBuf,
    data: Value,
@@ -90,6 +93,7 @@ pub struct Config {
 }

 #[allow(dead_code)]
+/// Top-level typed configuration parsed from TOML, containing optional sections for package, build, dependencies, etc.
 #[derive(Debug, Clone, Deserialize)]
 pub struct DcrConfig {
    #[serde(default)]
@@ -102,12 +106,43 @@ pub struct DcrConfig {
    pub toolchain: Option<ToolchainConfig>,
    #[serde(default)]
    pub workspace: BTreeMap<String, WorkspaceMemberConfig>,
+    #[serde(default)]
+    pub archive: Option<ArchiveConfig>,
 }

+#[allow(dead_code)]
+/// Configuration for archive output formats (e.g. EFI, bootable images).
+#[derive(Debug, Clone, Deserialize)]
+pub struct ArchiveConfig {
+    pub output: String,
+    pub format: String,
+    pub size: Option<String>,
+    pub offset: Option<String>,
+    pub label: Option<String>,
+    pub bootsector: Option<String>,
+    #[serde(default)]
+    pub layout: Vec<ArchiveLayout>,
+}
+
+#[allow(dead_code)]
+/// Layout definition for archive sections (from/to paths).
+#[derive(Debug, Clone, Deserialize)]
+pub struct ArchiveLayout {
+    pub from: String,
+    pub to: String,
+}
+
+/// Package metadata section (name, version, type, dcr-version).
 #[derive(Debug, Clone, Deserialize)]
 pub struct PackageConfig {
    pub name: String,
    pub version: String,
+    /// Minimum/target DCR tool version this project was authored for (`package.dcr-version`).
+    ///
+    /// Compared against the running `dcr` binary (`CARGO_PKG_VERSION`) on config load.
+    /// Missing or empty means "no pin" — no warning is emitted.
+    #[serde(default, rename = "dcr-version")]
+    pub dcr_version: Option<String>,
    #[serde(default, rename = "type")]
    pub pkg_type: Option<String>,
 }
@@ -121,6 +156,7 @@ fn default_compiler() -> String {
 }

 #[allow(dead_code)]
+/// Build configuration section, including language, standards, compiler, and output settings.
 #[derive(Debug, Clone, Deserialize)]
 pub struct BuildConfig {
    #[serde(default = "default_language")]
@@ -159,6 +195,7 @@ pub struct BuildConfig {
    pub qt: Option<bool>,
 }

+/// Language configuration can be a single string or array of strings (e.g. for multi-language builds).
 #[derive(Debug, Clone, Deserialize)]
 #[serde(untagged)]
 pub enum LanguageConfig {
@@ -175,6 +212,7 @@ impl LanguageConfig {
    }
 }

+/// Dependency configuration can be a version string or a full table of dependency details.
 #[allow(dead_code)]
 #[derive(Debug, Clone, Deserialize)]
 #[serde(untagged)]
@@ -183,6 +221,7 @@ pub enum DependencyConfig {
    Table(BTreeMap<String, Value>),
 }

+/// Toolchain configuration for custom compilers, assemblers, and linkers.
 #[derive(Debug, Clone, Deserialize, Default)]
 pub struct ToolchainConfig {
    pub cc: Option<String>,
@@ -193,6 +232,7 @@ pub struct ToolchainConfig {
    pub ld: Option<String>,
 }

+/// Workspace member configuration for multi-project workspaces.
 #[allow(dead_code)]
 #[derive(Debug, Clone, Deserialize)]
 pub struct WorkspaceMemberConfig {
@@ -204,6 +244,7 @@ pub struct WorkspaceMemberConfig {
 }

 impl Config {
+    /// Creates a new Config instance from a TOML file path. If the file does not exist, it creates a default one.
    pub fn new(path: &str) -> Result<Self, ConfigError> {
        let path = PathBuf::from(path);
        let (data, doc) = if path.exists() {
@@ -223,9 +264,11 @@ impl Config {
            doc,
        };
        cfg.validate()?;
+        cfg.warn_dcr_version_mismatch();
        Ok(cfg)
    }

+    /// Opens an existing Config from a TOML file path, failing if the file does not exist.
    pub fn open(path: &str) -> Result<Self, ConfigError> {
        let path = PathBuf::from(path);
        if !path.exists() {
@@ -240,20 +283,86 @@ impl Config {
            doc,
        };
        cfg.validate()?;
+        cfg.warn_dcr_version_mismatch();
        Ok(cfg)
    }

    #[allow(dead_code)]
+    /// Returns the fully typed configuration struct.
    pub fn typed(&self) -> &DcrConfig {
        &self.typed
    }

    #[allow(dead_code)]
+    /// Returns the package configuration if present.
    pub fn package(&self) -> Option<&PackageConfig> {
        self.typed.package.as_ref()
    }

+    /// Warn once per config path about `package.dcr-version` vs this `dcr` binary.
+    ///
+    /// - Missing/`""` pin → recommend adding `dcr-version`.
+    /// - Tool older than pin → project may use features this binary does not support.
+    /// - Tool newer than pin → project may rely on outdated defaults; consider bumping the pin.
+    ///
+    /// Never fails the load; warnings only. Equal pin is silent.
+    fn warn_dcr_version_mismatch(&self) {
+        let Some(pkg) = self.typed.package.as_ref() else {
+            return;
+        };
+
+        let path_key = self
+            .path
+            .canonicalize()
+            .unwrap_or_else(|_| self.path.clone())
+            .to_string_lossy()
+            .into_owned();
+        if !dcr_version_warn_once(&path_key) {
+            return;
+        }
+
+        let tool = env!("CARGO_PKG_VERSION");
+        let required = pkg
+            .dcr_version
+            .as_deref()
+            .map(str::trim)
+            .filter(|s| !s.is_empty());
+        let Some(required) = required else {
+            crate::utils::log::warn(&format!(
+                "package.dcr-version is missing in {}. Add e.g. dcr-version = \"{tool}\" \
+                 so collaborators know which dcr this project targets \
+                 (written automatically by `dcr new` / `dcr init`).",
+                self.path.display()
+            ));
+            return;
+        };
+
+        match crate::utils::build::compare_semver(tool, required) {
+            Some(std::cmp::Ordering::Less) => {
+                crate::utils::log::warn(&format!(
+                    "this project requires dcr {required} (package.dcr-version), \
+                     but you are running dcr {tool}. Some features may be missing or misbehave. \
+                     Upgrade dcr (e.g. `dcr --update`) or lower package.dcr-version if intentional."
+                ));
+            }
+            Some(std::cmp::Ordering::Greater) => {
+                crate::utils::log::warn(&format!(
+                    "this project pins dcr {required} (package.dcr-version), \
+                     but you are running newer dcr {tool}. Config/defaults may be outdated. \
+                     Review the changelog and bump package.dcr-version when the project is verified."
+                ));
+            }
+            Some(std::cmp::Ordering::Equal) => {}
+            None => {
+                crate::utils::log::warn(&format!(
+                    "package.dcr-version = \"{required}\" is not a valid semver (expected X.Y.Z); ignoring"
+                ));
+            }
+        }
+    }
+
    #[allow(dead_code)]
+    /// Returns the build configuration if present.
    pub fn build_config(&self) -> Option<&BuildConfig> {
        self.typed.build.as_ref()
    }
@@ -267,7 +376,7 @@ impl Config {
            && !self.typed.workspace.is_empty()
    }

-    /// Merge build fields from parent config into self where self has empty/default values.
+    /// Merges build fields from a parent config into self where self has empty/default values.
    /// Used for workspace member inheritance (build.inherit = true).
    pub fn merge_parent(&mut self, parent: &Config) {
        let fields: &[&str] = &[
@@ -345,24 +454,29 @@ impl Config {
        }
    }

+    /// Retrieves a nested value from the config data using dot-separated path.
    pub fn get(&self, key: &str) -> Option<&Value> {
        let parts: Vec<&str> = key.split('.').collect();
        get_path(&self.data, &parts)
    }

    #[allow(dead_code)]
+    /// Adds a new key-value pair to the configuration (alias for set).
    pub fn add(&mut self, key: &str, value: Value) -> Result<(), ConfigError> {
        self.set(key, value)
    }

+    /// Updates a configuration value at the given key path.
    pub fn edit(&mut self, key: &str, value: Value) -> Result<(), ConfigError> {
        self.set(key, value)
    }
    #[allow(dead_code)]
+    /// Checks if the configuration is valid without returning the error.
    pub fn check(&self) -> bool {
        self.validate().is_ok()
    }

+    /// Performs comprehensive validation of the configuration, including package, build, toolchain, and workspace rules.
    pub fn validate(&self) -> Result<(), ConfigError> {
        if self.is_workspace_only() {
            return self.validate_workspace();
@@ -721,11 +835,13 @@ fn default_toml_text() -> String {
        .ok()
        .and_then(|p| p.file_name().map(|v| v.to_string_lossy().to_string()))
        .unwrap_or_else(|| "project".to_string());
+    let dcr_version = env!("CARGO_PKG_VERSION");

    format!(
        "[package]\n\
         name = \"{name}\"\n\
         version = \"{DEFAULT_VERSION}\"\n\
+         dcr-version = \"{dcr_version}\"\n\
         type = \"none\"\n\
         description = \"\"\n\
         author = \"\"\n\
@@ -741,6 +857,17 @@ fn default_toml_text() -> String {
    )
 }

+fn dcr_version_warn_once(path_key: &str) -> bool {
+    use std::collections::HashSet;
+    use std::sync::{Mutex, OnceLock};
+    static WARNED: OnceLock<Mutex<HashSet<String>>> = OnceLock::new();
+    let set = WARNED.get_or_init(|| Mutex::new(HashSet::new()));
+    let Ok(mut guard) = set.lock() else {
+        return true;
+    };
+    guard.insert(path_key.to_string())
+}
+
 fn set_doc_path(doc: &mut DocumentMut, path: &[&str], value: &Value) -> Result<(), ConfigError> {
    let mut current = doc.as_table_mut();
    for &key in &path[..path.len().saturating_sub(1)] {
@@ -893,11 +1020,21 @@ mod tests {
        let dir = temp_dir("typed_config");
        let path = write_toml_file(
            &dir,
-            "[package]\nname = \"typed\"\nversion = \"1.2.3\"\ntype = \"lib\"\n\n[build]\nlanguage = [\"c\", \"c++\"]\nstandard = \"c11\"\ncompiler = \"clang\"\nkind = \"staticlib\"\ncflags = [\"-Wall\"]\n\n[dependencies]\nfoo = \"1.0.0\"\n",
+            "[package]\nname = \"typed\"\nversion = \"1.2.3\"\ndcr-version = \"0.8.4\"\ntype = \"lib\"\n\n[build]\nlanguage = [\"c\", \"c++\"]\nstandard = \"c11\"\ncompiler = \"clang\"\nkind = \"staticlib\"\ncflags = [\"-Wall\"]\n\n[dependencies]\nfoo = \"1.0.0\"\n",
        );
        let config = Config::open(&path.to_string_lossy()).unwrap();
        assert_eq!(config.package().unwrap().name, "typed");
        assert_eq!(config.typed().package.as_ref().unwrap().version, "1.2.3");
+        assert_eq!(
+            config
+                .typed()
+                .package
+                .as_ref()
+                .unwrap()
+                .dcr_version
+                .as_deref(),
+            Some("0.8.4")
+        );
        assert_eq!(config.build_config().unwrap().compiler, "clang");
        assert_eq!(config.build_config().unwrap().cflags, ["-Wall"]);
        assert!(config.typed().dependencies.contains_key("foo"));
--- a/src/core/deps/common.rs
+++ b/src/core/deps/common.rs
@@ -1,3 +1,4 @@
+/// Represents resolved dependencies for a build target, including include directories, library directories, and libraries.
 #[derive(Debug, Clone, Default)]
 pub struct ResolvedDeps {
    pub include_dirs: Vec<String>,
--- a/src/core/deps/lock.rs
+++ b/src/core/deps/lock.rs
@@ -18,6 +18,7 @@
 use std::fs;
 use std::path::Path;

+/// Represents a locked dependency entry containing its name, version, source, and checksum.
 #[derive(Debug, Clone)]
 pub struct DepLock {
    pub name: String,
@@ -26,6 +27,7 @@ pub struct DepLock {
    pub source: String,
 }

+/// Writes the dcr.lock file in a Cargo-like format. The project entry comes first, followed by dependency entries.
 pub fn write_lock(
    project_root: &Path,
    project_name: &str,
@@ -47,6 +49,7 @@ pub fn write_lock(
    }
    out.push('\n');

+    // Write metadata for each package in the dependencies list
    for pkg in packages {
        out.push_str("[[package]]\n");
        out.push_str(&format!("name = \"{}\"\n", escape_value(&pkg.name)));
@@ -60,6 +63,7 @@ pub fn write_lock(
    Ok(())
 }

+/// Converts a list of strings into a comma-separated TOML array by quoting each item.
 fn quote_list(items: &[String]) -> String {
    items
        .iter()
@@ -68,6 +72,7 @@ fn quote_list(items: &[String]) -> String {
        .join(", ")
 }

+/// Escapes backslashes and double quotes in a string to make it safe for TOML.
 fn escape_value(input: &str) -> String {
    input.replace('\\', "\\\\").replace('"', "\\\"")
 }
--- a/src/core/deps/mod.rs
+++ b/src/core/deps/mod.rs
@@ -15,6 +15,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.

+/// Core dependency resolver for DCR projects.
 pub mod common;
 pub mod lock;
 pub mod register;
@@ -24,6 +25,7 @@ use crate::core::deps::common::ResolvedDeps;
 use crate::core::deps::lock::{DepLock, write_lock};
 use std::path::Path;

+/// Returns the version string from a dependency's dcr.toml file, or an empty string if missing.
 fn dep_version(path: &Path) -> String {
    Config::open(&path.join("dcr.toml").to_string_lossy())
        .ok()
@@ -35,6 +37,18 @@ fn dep_version(path: &Path) -> String {
        .unwrap_or_default()
 }

+/// Resolves dependencies from config into include/lib dirs and lib names, and writes the lock file.
+///
+/// Registry and path deps contribute to `ResolvedDeps`. Git deps are recorded in the lock only
+/// (no fetch or include/lib resolution).
+///
+/// # Parameters
+/// - `config`: Loaded `dcr.toml`.
+/// - `_profile` / `_target`: Reserved for future profile/target-specific deps.
+/// - `project_root`: Root used to resolve path deps and write `dcr.lock`.
+///
+/// # Returns
+/// Aggregated include/lib/libs, or an error string on resolve/lock failure.
 pub fn resolve_deps(
    config: &Config,
    _profile: &str,
@@ -57,6 +71,7 @@ pub fn resolve_deps(
    let mut lock_packages: Vec<DepLock> = Vec::new();

    if let Some(deps) = deps_table {
+        // Process each dependency declaration in the TOML table
        for (name, value) in deps {
            if register::is_registry_dep(value) {
                let pkg_info = register::resolve_package_from_registry(name)?;
@@ -157,6 +172,7 @@ pub fn resolve_deps(
        }
    }

+    // Write the lock file with all resolved dependencies
    write_lock(
        project_root,
        &project_name,
@@ -167,11 +183,13 @@ pub fn resolve_deps(
    Ok(resolved)
 }

+/// Git dependency specification (url + optional version/ref for the lockfile).
 struct GitDep<'a> {
    url: &'a str,
    version: Option<String>,
 }

+/// Parses a git dependency from a TOML value table.
 fn git_dep(value: &toml::Value) -> Option<GitDep<'_>> {
    if let Some(table) = value.as_table()
        && let Some(url) = table.get("git").and_then(|v| v.as_str())
@@ -185,6 +203,7 @@ fn git_dep(value: &toml::Value) -> Option<GitDep<'_>> {
    None
 }

+/// Extracts the path for a path-based dependency, supporting both table format and legacy string format.
 fn path_dep_path(value: &toml::Value) -> Option<&str> {
    if let Some(table) = value.as_table() {
        return table.get("path").and_then(|v| v.as_str());
@@ -192,12 +211,14 @@ fn path_dep_path(value: &toml::Value) -> Option<&str> {
    register::path_from_string_dep(value)
 }

+/// Adds a directory path to the list if it exists on the filesystem.
 fn push_if_exists(paths: &mut Vec<String>, path: &Path) {
    if path.exists() {
        paths.push(path.to_string_lossy().to_string());
    }
 }

+/// Adds common library directory candidates to the list if they exist.
 fn push_default_lib_dirs(paths: &mut Vec<String>, dep_root: &Path) {
    for dir in ["lib", "lib64"] {
        push_if_exists(paths, &dep_root.join(dir));
@@ -210,6 +231,7 @@ mod tests {
    use super::*;
    use toml::Value;

+    /// Tests that path_dep_path correctly handles both TOML table and legacy string inputs for path dependencies.
    #[test]
    fn path_dep_path_supports_table_and_legacy_strings() {
        let table = Value::Table(
@@ -232,6 +254,7 @@ mod tests {
        assert_eq!(path_dep_path(&Value::String("1.2.3".to_string())), None);
    }

+    /// Verifies that push_default_lib_dirs includes the target/lib directory when it exists.
    #[test]
    fn default_lib_dirs_include_packaged_library_output() {
        let root = std::env::temp_dir().join(format!(
@@ -242,10 +265,13 @@ mod tests {
                .unwrap()
                .as_nanos()
        ));
-        std::fs::create_dir_all(root.join("target/lib")).unwrap();
+        std::fs::create_dir_all(root.join("target").join("lib")).unwrap();
        let mut paths = Vec::new();
        push_default_lib_dirs(&mut paths, &root);
-        assert!(paths.iter().any(|p| p.ends_with("target/lib")));
+        assert!(paths.iter().any(|p| {
+            let n = p.replace('\\', "/");
+            n.ends_with("target/lib")
+        }));
        let _ = std::fs::remove_dir_all(root);
    }
 }
--- a/src/core/deps/register.rs
+++ b/src/core/deps/register.rs
@@ -21,25 +21,30 @@ use std::fs;
 use std::path::{Path, PathBuf};
 use toml::Value as TomlValue;

+/// Represents a registry configuration entry with its URL and priority.
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Registry {
    pub url: String,
    pub priority: i32,
 }

+/// Configuration struct for DCR registries, mapping registry names to Registry details.
 #[derive(Debug, Serialize, Deserialize)]
 pub struct DcrConfig {
    pub registry: std::collections::HashMap<String, Registry>,
 }

+/// Helper function to get the user's home directory path.
 fn home_dir() -> Option<PathBuf> {
    crate::utils::fs::home_dir()
 }

+/// Helper to get the DCR config directory path.
 fn dcr_config_dir() -> Option<PathBuf> {
    home_dir().map(|h| h.join(".dcr"))
 }

+/// Loads DCR registry configuration from the TOML file in the user's home directory.
 pub fn get_registry_config() -> Option<DcrConfig> {
    let home = home_dir()?;
    let config_path = home.join(".dcr/config.toml");
@@ -51,6 +56,7 @@ pub fn get_registry_config() -> Option<DcrConfig> {
    toml::from_str(&content).ok()
 }

+/// Returns the path to the registry index file, preferring the DCR_INDEX_PATH env var or falling back to ~/.dcr/index.json.
 pub fn get_index_path() -> PathBuf {
    std::env::var("DCR_INDEX_PATH")
        .map(PathBuf::from)
@@ -61,6 +67,7 @@ pub fn get_index_path() -> PathBuf {
        })
 }

+/// Returns the root directory for registry cache, based on the index path's parent, creating it if necessary.
 pub fn get_registry_cache_root() -> PathBuf {
    let index_path = get_index_path();
    if let Some(parent) = index_path.parent() {
@@ -76,6 +83,7 @@ pub fn get_registry_cache_root() -> PathBuf {
    }
 }

+/// Extracts the package root path from registry info. If the path points to a dcr.toml manifest, returns its parent directory.
 pub fn package_root_from_registry_info(pkg_info: &JsonValue) -> Result<PathBuf, String> {
    let raw_path = pkg_info
        .get("path")
@@ -85,12 +93,7 @@ pub fn package_root_from_registry_info(pkg_info: &JsonValue) -> Result<PathBuf,
        return Err("Registry package path is empty".to_string());
    }

-    let path = Path::new(raw_path);
-    let full_path = if path.is_absolute() {
-        path.to_path_buf()
-    } else {
-        get_registry_cache_root().join(path)
-    };
+    let full_path = registry_path_to_pathbuf(raw_path.trim());

    if full_path.file_name().and_then(|v| v.to_str()) == Some("dcr.toml") {
        return full_path
@@ -102,14 +105,60 @@ pub fn package_root_from_registry_info(pkg_info: &JsonValue) -> Result<PathBuf,
    Ok(full_path)
 }

+/// Converts a raw registry path string to a PathBuf, handling file:// prefixes, Windows extended paths, and relative paths by joining to cache root.
+pub fn registry_path_to_pathbuf(raw: &str) -> PathBuf {
+    let s = raw.trim();
+    if let Some(rest) = s.strip_prefix("file://") {
+        if rest.len() >= 3 && rest.as_bytes()[0] == b'/' && rest.as_bytes()[2] == b':' {
+            return PathBuf::from(&rest[1..]);
+        }
+        if rest.len() >= 2 && rest.as_bytes()[1] == b':' {
+            return PathBuf::from(rest);
+        }
+        if rest.starts_with('/') {
+            return PathBuf::from(rest);
+        }
+        return PathBuf::from(format!("/{rest}"));
+    }
+
+    let mut s = s.replace('\\', "/");
+    if let Some(rest) = s.strip_prefix("//?/") {
+        s = rest.to_string();
+    } else if let Some(rest) = s.strip_prefix("//./") {
+        s = rest.to_string();
+    }
+    if s.len() >= 3 && s.as_bytes()[0] == b'/' && s.as_bytes()[2] == b':' {
+        s = s[1..].to_string();
+    }
+
+    let path = PathBuf::from(&s);
+    if path.is_absolute() || (s.len() >= 2 && s.as_bytes()[1] == b':') || s.starts_with('/') {
+        path
+    } else {
+        get_registry_cache_root().join(path)
+    }
+}
+
+/// Returns the include directory path for a dependency root, typically under target/include.
 pub fn registry_include_dir(dep_root: &Path) -> PathBuf {
    dep_root.join("target").join("include")
 }

+/// Returns the library directory path for a dependency root, typically under target/lib.
 pub fn registry_lib_dir(dep_root: &Path) -> PathBuf {
    dep_root.join("target").join("lib")
 }

+/// Looks up `name` in the local package index (`DCR_INDEX_PATH` / `~/.dcr/index.json`).
+///
+/// Configured registries are sorted by priority, but the lookup currently always reads the
+/// same local index path (per-registry URLs are unused).
+///
+/// # Parameters
+/// - `name`: Package name as in the index.
+///
+/// # Returns
+/// Package JSON object, or an error if config/index is missing or the name is absent.
 pub fn resolve_package_from_registry(name: &str) -> Result<JsonValue, String> {
    let config = get_registry_config().ok_or("No registry config found")?;
    let mut registries: Vec<(&String, &Registry)> = config.registry.iter().collect();
@@ -137,6 +186,10 @@ pub fn resolve_package_from_registry(name: &str) -> Result<JsonValue, String> {
    ))
 }

+/// True if the TOML value is a registry-style dependency.
+///
+/// Strings: not path-like and not git-like. Tables: have version/features/optional/registry
+/// and no `git`/`path`/`url` keys.
 pub fn is_registry_dep(value: &TomlValue) -> bool {
    if let Some(raw) = value.as_str() {
        let raw = raw.trim();
@@ -155,6 +208,7 @@ pub fn is_registry_dep(value: &TomlValue) -> bool {
    }
 }

+/// Extracts the path string from a dependency value if it's a path-like dependency.
 pub fn path_from_string_dep(value: &TomlValue) -> Option<&str> {
    let raw = value.as_str()?.trim();
    if let Some(path) = raw.strip_prefix("path:") {
@@ -166,6 +220,7 @@ pub fn path_from_string_dep(value: &TomlValue) -> Option<&str> {
    None
 }

+/// Helper to check if a string represents a local file path.
 fn is_path_like_string(raw: &str) -> bool {
    raw.starts_with("path:")
        || raw.starts_with("./")
@@ -175,6 +230,7 @@ fn is_path_like_string(raw: &str) -> bool {
        || raw.contains('\\')
 }

+/// Helper to check if a string represents a git or remote dependency.
 fn is_git_like_string(raw: &str) -> bool {
    raw.starts_with("git:")
        || raw.starts_with("github:")
@@ -219,16 +275,44 @@ mod tests {

    #[test]
    fn registry_package_root_accepts_package_dir_or_manifest_path() {
-        let pkg = serde_json::json!({ "path": "/tmp/pkg" });
+        let root = std::env::temp_dir().join(format!("dcr_reg_pkg_{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&root);
+        std::fs::create_dir_all(&root).unwrap();
+        let root_str = root.to_string_lossy().replace('\\', "/");
+
+        let pkg = serde_json::json!({ "path": root_str });
        assert_eq!(
-            package_root_from_registry_info(&pkg).unwrap(),
-            PathBuf::from("/tmp/pkg")
+            package_root_from_registry_info(&pkg)
+                .unwrap()
+                .to_string_lossy()
+                .replace('\\', "/"),
+            root_str
        );

-        let pkg = serde_json::json!({ "path": "/tmp/pkg/dcr.toml" });
+        let manifest = format!("{root_str}/dcr.toml");
+        let pkg = serde_json::json!({ "path": manifest });
        assert_eq!(
-            package_root_from_registry_info(&pkg).unwrap(),
-            PathBuf::from("/tmp/pkg")
+            package_root_from_registry_info(&pkg)
+                .unwrap()
+                .to_string_lossy()
+                .replace('\\', "/"),
+            root_str
        );
+        let _ = std::fs::remove_dir_all(&root);
+    }
+
+    #[test]
+    fn registry_path_strips_windows_extended_prefix() {
+        let p = registry_path_to_pathbuf("//?/D:/cache/mylib");
+        let s = p.to_string_lossy().replace('\\', "/");
+        assert_eq!(s, "D:/cache/mylib");
+
+        let p2 = registry_path_to_pathbuf("/D:/cache/mylib");
+        let s2 = p2.to_string_lossy().replace('\\', "/");
+        assert_eq!(s2, "D:/cache/mylib");
+
+        let p3 = registry_path_to_pathbuf("file:///D:/cache/mylib");
+        let s3 = p3.to_string_lossy().replace('\\', "/");
+        assert_eq!(s3, "D:/cache/mylib");
    }
 }
--- a/src/core/mod.rs
+++ b/src/core/mod.rs
@@ -15,6 +15,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.

+/// Core module for DCR, a Cargo-like C/C++ project manager.
 pub mod build;
 pub mod build_config;
 pub mod deps;
--- a/src/core/registry.rs
+++ b/src/core/registry.rs
@@ -15,33 +15,40 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.

+/// Registry configuration management for DCR.
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::fs;
 use std::path::PathBuf;

+/// Represents a registry configuration entry with its URL and priority.
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Registry {
    pub url: String,
    pub priority: i32,
 }

+/// Represents the overall configuration loaded from config.toml, mapping registry names to their details.
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Config {
    pub registry: HashMap<String, Registry>,
 }

+/// Manages the DCR registry configuration, loading from ~/.dcr/config.toml.
 pub struct RegistryManager {
    pub config: Config,
    #[allow(dead_code)]
    pub path: PathBuf,
 }

+/// Returns the user's home directory path, used to locate the config file.
 fn home_dir() -> Option<PathBuf> {
    crate::utils::fs::home_dir()
 }

 impl RegistryManager {
+    /// Loads the registry configuration from ~/.dcr/config.toml.
+    /// Returns an error if the config file is missing.
    pub fn load() -> Result<Self, Box<dyn std::error::Error>> {
        let dcr_dir = home_dir()
            .ok_or("Cannot determine home directory")?
@@ -53,6 +60,7 @@ impl RegistryManager {
        }

        let content = fs::read_to_string(&config_path)?;
+        // Deserialize the TOML content into the Config struct
        let config: Config = toml::from_str(&content)?;

        Ok(Self {
--- a/src/core/runner.rs
+++ b/src/core/runner.rs
@@ -19,10 +19,26 @@ use crate::platform;
 use std::path::Path;
 use std::process::Command;

-pub fn run_binary(project_name: &str, profile: &str, target_dir: Option<&str>) -> i32 {
+/// Runs the built binary for a project, forwarding `bin_args`.
+///
+/// # Parameters
+/// - `project_name`: Package/binary name used to resolve the artifact path.
+/// - `profile`: Build profile segment under `target/`.
+/// - `target_dir`: Optional artifact directory override.
+/// - `bin_args`: Arguments passed to the process.
+///
+/// # Returns
+/// Child exit code, or `1` if the binary is missing or cannot be spawned.
+pub fn run_binary(
+    project_name: &str,
+    profile: &str,
+    target_dir: Option<&str>,
+    bin_args: &[String],
+) -> i32 {
    let bin_path = platform::bin_path(profile, project_name, target_dir);
+    // Check if the binary exists before attempting to run it
    if Path::new(&bin_path).exists() {
-        let status = Command::new(&bin_path).status();
+        let status = Command::new(&bin_path).args(bin_args).status();
        match status {
            Ok(s) => {
                return s.code().unwrap_or(0);
@@ -32,5 +48,6 @@ pub fn run_binary(project_name: &str, profile: &str, target_dir: Option<&str>) -
            }
        }
    }
+    // Return 1 if binary not found or execution failed
    1
 }
--- a/src/core/vcs/git.rs
+++ b/src/core/vcs/git.rs
@@ -18,14 +18,21 @@
 use std::fs;
 use std::path::Path;

-// creating git init and .gitignore
+/// Initializes a Git repository in the target directory and configures its `.gitignore` file.
+///
+/// Executes `git init` via the VCS utility module, creates a default `.gitignore` if none exists,
+/// or updates an existing `.gitignore` to ensure `.dcr/` and build outputs are ignored.
 pub fn init(path: &Path) -> Result<(), String> {
    crate::utils::git::git_init(path)?;

+    // Populate default .gitignore entries or append DCR metadata rules.
    let gitignore_path = path.join(".gitignore");
    if !gitignore_path.exists() {
-        fs::write(&gitignore_path, "/target\n")
+        fs::write(&gitignore_path, "/target\n.dcr/\n")
            .map_err(|e| format!("failed to create .gitignore: {}", e))?;
+    } else {
+        crate::utils::fs::ensure_gitignore_has_dcr(path)
+            .map_err(|e| format!("failed to update .gitignore: {}", e))?;
    }

    Ok(())
--- a/src/core/vcs/mod.rs
+++ b/src/core/vcs/mod.rs
@@ -15,10 +15,12 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.

+/// Module for version control system (VCS) integration.
 pub mod git;

 use std::path::Path;

+/// Represents the version control system kind to use.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum VcsKind {
    Git,
@@ -26,6 +28,7 @@ pub enum VcsKind {
 }

 impl VcsKind {
+    /// Parses the given string into a VcsKind.
    pub fn parse(s: &str) -> Result<Self, String> {
        match s.to_lowercase().as_str() {
            "git" => Ok(Self::Git),
@@ -35,6 +38,7 @@ impl VcsKind {
    }
 }

+/// Initializes the VCS for the provided path.
 pub fn init_vcs(kind: VcsKind, path: &Path) -> Result<(), String> {
    match kind {
        VcsKind::Git => git::init(path),
@@ -42,8 +46,9 @@ pub fn init_vcs(kind: VcsKind, path: &Path) -> Result<(), String> {
    }
 }

-// look for git repo in parents to avoid nested repos
+/// Finds an existing VCS in the parent directories of the given path.
 pub fn find_existing_vcs(path: &Path) -> Option<VcsKind> {
+    // look for git repo in parents to avoid nested repos
    let mut current = if path.is_file() {
        path.parent()
    } else {
--- a/src/core/workspace.rs
+++ b/src/core/workspace.rs
@@ -21,6 +21,7 @@ use std::collections::{HashMap, HashSet};
 use std::path::{Path, PathBuf};
 use toml::Value;

+/// Represents a member of the workspace.
 #[derive(Debug, Clone)]
 pub struct WorkspaceMember {
    pub name: String,
@@ -29,12 +30,14 @@ pub struct WorkspaceMember {
    pub main: bool,
 }

+/// Represents the workspace as a collection of members.
 #[derive(Debug, Clone)]
 pub struct Workspace {
    pub members: Vec<WorkspaceMember>,
 }

 impl Workspace {
+    /// Returns the main workspace member, preferring the one with `main: true` or the first member.
    pub fn main_member(&self) -> Option<&WorkspaceMember> {
        self.members
            .iter()
@@ -43,6 +46,17 @@ impl Workspace {
    }
 }

+/// Parses the workspace configuration from the TOML config.
+///
+/// # Parameters
+/// - `config`: Root `dcr.toml` (may be workspace-only or mixed).
+/// - `profile` / `target`: Select profile- and target-specific `[workspace.*]` tables.
+/// - `root`: Workspace root used to resolve member paths.
+///
+/// # Returns
+/// - `Ok(None)` if no workspace table applies.
+/// - `Ok(Some(Workspace))` with members (and optional main).
+/// - `Err` on invalid member paths or config shape.
 pub fn parse_workspace(
    config: &Config,
    profile: &str,
@@ -50,6 +64,7 @@ pub fn parse_workspace(
    root: &Path,
 ) -> Result<Option<Workspace>, String> {
    let mut table = None;
+    // Create ordered list of possible config keys for lookup
    let combinations = if let Some(t) = target {
        let normalized_t = normalize_target_os(t);
        vec![
@@ -103,6 +118,7 @@ pub fn parse_workspace(
    Ok(Some(ws))
 }

+/// Resolves a path, making it absolute if relative to root.
 fn resolve_path(root: &Path, raw: &str) -> Result<PathBuf, String> {
    let p = Path::new(raw);
    let full = if p.is_absolute() {
@@ -113,6 +129,7 @@ fn resolve_path(root: &Path, raw: &str) -> Result<PathBuf, String> {
    Ok(full)
 }

+/// Parses dependencies list from TOML value into Vec<String>.
 fn parse_deps(value: Option<&Value>) -> Result<Vec<String>, String> {
    let Some(value) = value else {
        return Ok(Vec::new());
@@ -130,12 +147,14 @@ fn parse_deps(value: Option<&Value>) -> Result<Vec<String>, String> {
    Ok(out)
 }

+/// Performs a topological sort on members to handle dependencies and detect cycles.
 fn topo_sort(members: &[WorkspaceMember]) -> Result<Vec<WorkspaceMember>, String> {
    let mut map = HashMap::new();
    for m in members {
        map.insert(m.name.clone(), m.clone());
    }
    let mut state: HashMap<String, u8> = HashMap::new();
+    // Use 0=unvisited, 1=visiting, 2=visited for cycle detection
    let mut order: Vec<WorkspaceMember> = Vec::new();

    for name in map.keys() {
@@ -146,12 +165,14 @@ fn topo_sort(members: &[WorkspaceMember]) -> Result<Vec<WorkspaceMember>, String
    Ok(order)
 }

+/// Recursive function for DFS-based topological sort with cycle detection.
 fn visit(
    name: &str,
    map: &HashMap<String, WorkspaceMember>,
    state: &mut HashMap<String, u8>,
    order: &mut Vec<WorkspaceMember>,
 ) -> Result<(), String> {
+    // Check current visit state to detect cycles
    match state.get(name).copied().unwrap_or(0) {
        1 => return Err(format!("workspace dependency cycle at {name}")),
        2 => return Ok(()),
--- a/src/main.rs
+++ b/src/main.rs
@@ -21,6 +21,11 @@ mod core;
 mod platform;
 mod utils;

+/// Main entry point for DCR, a Cargo-like C/C++ project manager.
+///
+/// Collects command-line arguments via `std::env::args()` and dispatches to the
+/// appropriate subcommand handler. With fewer than two arguments, shows help and
+/// exits with code 0; otherwise exits with the handler's exit code.
 fn main() {
    let args: Vec<String> = std::env::args().collect();

@@ -57,7 +62,7 @@ fn main() {
        "--update" => cli::flag_update::flag_update(rest),
        _ => {
            error("Unknown command or argument");
-            0
+            1
        }
    };

--- a/src/platform/bsd.rs
+++ b/src/platform/bsd.rs
@@ -15,63 +15,51 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.

+use super::path_util::{default_bin_rel, default_lib_rel, join_dir};
+use crate::utils::build::default_target_triple;
+
+/// Returns the host target triple used for default artifact paths on BSD.
+fn host_triple() -> String {
+    default_target_triple()
+}
+
+/// Returns the path to a binary for the given profile, name, and optional target directory.
 pub fn bin_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
    match target_dir {
-        Some(dir) => format!("{}/{}", dir.trim_end_matches('/'), name),
-        None => {
-            let arch = std::env::consts::ARCH;
-            let os = std::env::consts::OS;
-            let target = format!("{arch}-unknown-{os}");
-            format!("./target/{target}/{profile}/{name}")
-        }
+        Some(dir) => join_dir(dir, name),
+        None => default_bin_rel(profile, name, Some(&host_triple())),
    }
 }

+/// Returns the path to a static library for the given profile, name, and optional target directory.
 pub fn lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    let file = format!("lib{name}.a");
    match target_dir {
-        Some(dir) => format!("{}/lib{}.a", dir.trim_end_matches('/'), name),
-        None => {
-            let arch = std::env::consts::ARCH;
-            let os = std::env::consts::OS;
-            let target = format!("{arch}-unknown-{os}");
-            format!("./target/{target}/{profile}/lib{name}.a")
-        }
+        Some(dir) => join_dir(dir, &file),
+        None => default_lib_rel(profile, &file, Some(&host_triple())),
    }
 }

+/// Returns the path to an ELF binary for the given profile, name, and optional target directory.
 pub fn elf_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
-    match target_dir {
-        Some(dir) => format!("{}/{}", dir.trim_end_matches('/'), name),
-        None => {
-            let arch = std::env::consts::ARCH;
-            let os = std::env::consts::OS;
-            let target = format!("{arch}-unknown-{os}");
-            format!("./target/{target}/{profile}/{name}")
-        }
-    }
+    bin_path(profile, name, target_dir)
 }

+/// Returns the path to an EFI binary for the given profile, name, and optional target directory.
 pub fn efi_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    let file = format!("{name}.efi");
    match target_dir {
-        Some(dir) => format!("{}/{}.efi", dir.trim_end_matches('/'), name),
-        None => {
-            let arch = std::env::consts::ARCH;
-            let os = std::env::consts::OS;
-            let target = format!("{arch}-unknown-{os}");
-            format!("./target/{target}/{profile}/{name}.efi")
-        }
+        Some(dir) => join_dir(dir, &file),
+        None => default_lib_rel(profile, &file, Some(&host_triple())),
    }
 }

+/// Returns the path to a shared library for the given profile, name, and optional target directory.
 pub fn shared_lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    let file = format!("lib{name}.so");
    match target_dir {
-        Some(dir) => format!("{}/lib{}.so", dir.trim_end_matches('/'), name),
-        None => {
-            let arch = std::env::consts::ARCH;
-            let os = std::env::consts::OS;
-            let target = format!("{arch}-unknown-{os}");
-            format!("./target/{target}/{profile}/lib{name}.so")
-        }
+        Some(dir) => join_dir(dir, &file),
+        None => default_lib_rel(profile, &file, Some(&host_triple())),
    }
 }

@@ -81,25 +69,19 @@ mod tests {

    #[test]
    fn bin_path_default() {
-        let arch = std::env::consts::ARCH;
-        let os = std::env::consts::OS;
-        let expected = format!("./target/{arch}-unknown-{os}/debug/hello");
+        let expected = default_bin_rel("debug", "hello", Some(&host_triple()));
        assert_eq!(bin_path("debug", "hello", None), expected);
    }

    #[test]
    fn lib_path_default() {
-        let arch = std::env::consts::ARCH;
-        let os = std::env::consts::OS;
-        let expected = format!("./target/{arch}-unknown-{os}/debug/libmylib.a");
+        let expected = default_lib_rel("debug", "libmylib.a", Some(&host_triple()));
        assert_eq!(lib_path("debug", "mylib", None), expected);
    }

    #[test]
    fn shared_lib_path_default() {
-        let arch = std::env::consts::ARCH;
-        let os = std::env::consts::OS;
-        let expected = format!("./target/{arch}-unknown-{os}/debug/libmylib.so");
+        let expected = default_lib_rel("debug", "libmylib.so", Some(&host_triple()));
        assert_eq!(shared_lib_path("debug", "mylib", None), expected);
    }
 }
--- a/src/platform/linux.rs
+++ b/src/platform/linux.rs
@@ -15,58 +15,52 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.

+use super::path_util::{default_bin_rel, default_lib_rel, join_dir};
+use crate::utils::build::default_target_triple;
+
+/// Returns the default target triple string for the host platform.
+fn host_triple() -> String {
+    default_target_triple()
+}
+
+/// Constructs the path to a binary executable.
+/// If `target_dir` is provided, joins it with the name; otherwise uses default_bin_rel with the host triple.
 pub fn bin_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
    match target_dir {
-        Some(dir) => format!("{}/{}", dir.trim_end_matches('/'), name),
-        None => {
-            let arch = std::env::consts::ARCH;
-            let target = format!("{arch}-unknown-linux-gnu");
-            format!("./target/{target}/{profile}/{name}")
-        }
+        Some(dir) => join_dir(dir, name),
+        None => default_bin_rel(profile, name, Some(&host_triple())),
    }
 }

+/// Constructs the path to a static library archive.
 pub fn lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    let file = format!("lib{name}.a");
    match target_dir {
-        Some(dir) => format!("{}/lib{}.a", dir.trim_end_matches('/'), name),
-        None => {
-            let arch = std::env::consts::ARCH;
-            let target = format!("{arch}-unknown-linux-gnu");
-            format!("./target/{target}/{profile}/lib{name}.a")
-        }
+        Some(dir) => join_dir(dir, &file),
+        None => default_lib_rel(profile, &file, Some(&host_triple())),
    }
 }

+/// Constructs the path to an ELF binary.
 pub fn elf_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
-    match target_dir {
-        Some(dir) => format!("{}/{}", dir.trim_end_matches('/'), name),
-        None => {
-            let arch = std::env::consts::ARCH;
-            let target = format!("{arch}-unknown-linux-gnu");
-            format!("./target/{target}/{profile}/{name}")
-        }
-    }
+    bin_path(profile, name, target_dir)
 }

+/// Constructs the path to an EFI binary.
 pub fn efi_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    let file = format!("{name}.efi");
    match target_dir {
-        Some(dir) => format!("{}/{}.efi", dir.trim_end_matches('/'), name),
-        None => {
-            let arch = std::env::consts::ARCH;
-            let target = format!("{arch}-unknown-linux-gnu");
-            format!("./target/{target}/{profile}/{name}.efi")
-        }
+        Some(dir) => join_dir(dir, &file),
+        None => default_lib_rel(profile, &file, Some(&host_triple())),
    }
 }

+/// Constructs the path to a shared library.
 pub fn shared_lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    let file = format!("lib{name}.so");
    match target_dir {
-        Some(dir) => format!("{}/lib{}.so", dir.trim_end_matches('/'), name),
-        None => {
-            let arch = std::env::consts::ARCH;
-            let target = format!("{arch}-unknown-linux-gnu");
-            format!("./target/{target}/{profile}/lib{name}.so")
-        }
+        Some(dir) => join_dir(dir, &file),
+        None => default_lib_rel(profile, &file, Some(&host_triple())),
    }
 }

@@ -76,44 +70,49 @@ mod tests {

    #[test]
    fn bin_path_default() {
-        let arch = std::env::consts::ARCH;
-        let expected = format!("./target/{arch}-unknown-linux-gnu/debug/hello");
+        let expected = default_bin_rel("debug", "hello", Some(&host_triple()));
        assert_eq!(bin_path("debug", "hello", None), expected);
    }

    #[test]
    fn bin_path_release() {
-        let arch = std::env::consts::ARCH;
-        let expected = format!("./target/{arch}-unknown-linux-gnu/release/hello");
+        let expected = default_bin_rel("release", "hello", Some(&host_triple()));
        assert_eq!(bin_path("release", "hello", None), expected);
    }

    #[test]
    fn bin_path_custom_target() {
-        assert_eq!(bin_path("debug", "hello", Some("out")), "out/hello");
+        assert_eq!(
+            bin_path("debug", "hello", Some("out")),
+            join_dir("out", "hello")
+        );
    }

    #[test]
    fn bin_path_custom_target_trailing_slash() {
-        assert_eq!(bin_path("debug", "hello", Some("out/")), "out/hello");
+        assert_eq!(
+            bin_path("debug", "hello", Some("out/")),
+            join_dir("out/", "hello")
+        );
    }

    #[test]
    fn lib_path_default() {
-        let arch = std::env::consts::ARCH;
-        let expected = format!("./target/{arch}-unknown-linux-gnu/debug/libmylib.a");
+        let expected = default_lib_rel("debug", "libmylib.a", Some(&host_triple()));
        assert_eq!(lib_path("debug", "mylib", None), expected);
    }

    #[test]
    fn lib_path_custom_target() {
-        assert_eq!(lib_path("debug", "mylib", Some("out")), "out/libmylib.a");
+        assert_eq!(
+            lib_path("debug", "mylib", Some("out")),
+            join_dir("out", "libmylib.a")
+        );
    }

    #[test]
    fn shared_lib_path_default() {
-        let arch = std::env::consts::ARCH;
-        let expected = format!("./target/{arch}-unknown-linux-gnu/debug/libmylib.so");
+        let expected = default_lib_rel("debug", "libmylib.so", Some(&host_triple()));
        assert_eq!(shared_lib_path("debug", "mylib", None), expected);
    }

@@ -121,7 +120,7 @@ mod tests {
    fn shared_lib_path_custom_target() {
        assert_eq!(
            shared_lib_path("release", "mylib", Some("dist")),
-            "dist/libmylib.so"
+            join_dir("dist", "libmylib.so")
        );
    }
 }
--- a/src/platform/macos.rs
+++ b/src/platform/macos.rs
@@ -15,37 +15,48 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.

+/// macOS-specific utilities for constructing paths to build artifacts.
+///
+/// This module defines functions to generate paths for binaries, static
+/// libraries, shared libraries, ELF files, and EFI executables on macOS.
+use super::path_util::{default_bin_rel, default_lib_rel, join_dir};
+
+/// Constructs the path to a binary for the given profile, name, and optional target directory.
 pub fn bin_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
    match target_dir {
-        Some(dir) => format!("{}/{}", dir.trim_end_matches('/'), name),
-        None => format!("./target/{profile}/{name}"),
+        Some(dir) => join_dir(dir, name),
+        None => default_bin_rel(profile, name, None),
    }
 }

+/// Constructs the path to a static library archive for the given profile, name, and optional target directory.
 pub fn lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    let file = format!("lib{name}.a");
    match target_dir {
-        Some(dir) => format!("{}/lib{}.a", dir.trim_end_matches('/'), name),
-        None => format!("./target/{profile}/lib{name}.a"),
+        Some(dir) => join_dir(dir, &file),
+        None => default_lib_rel(profile, &file, None),
    }
 }

+/// Constructs the path to an ELF binary for the given profile, name, and optional target directory.
 pub fn elf_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
-    match target_dir {
-        Some(dir) => format!("{}/{}", dir.trim_end_matches('/'), name),
-        None => format!("./target/{profile}/{name}"),
-    }
+    bin_path(profile, name, target_dir)
 }

+/// Constructs the path to an EFI executable for the given profile, name, and optional target directory.
 pub fn efi_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    let file = format!("{name}.efi");
    match target_dir {
-        Some(dir) => format!("{}/{}.efi", dir.trim_end_matches('/'), name),
-        None => format!("./target/{profile}/{name}.efi"),
+        Some(dir) => join_dir(dir, &file),
+        None => default_lib_rel(profile, &file, None),
    }
 }

+/// Constructs the path to a shared library for the given profile, name, and optional target directory.
 pub fn shared_lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    let file = format!("lib{name}.dylib");
    match target_dir {
-        Some(dir) => format!("{}/lib{}.dylib", dir.trim_end_matches('/'), name),
-        None => format!("./target/{profile}/lib{name}.dylib"),
+        Some(dir) => join_dir(dir, &file),
+        None => default_lib_rel(profile, &file, None),
    }
 }
--- a/src/platform/mod.rs
+++ b/src/platform/mod.rs
@@ -26,6 +26,7 @@ pub mod bsd;
 pub mod linux;
 #[cfg(target_os = "macos")]
 pub mod macos;
+mod path_util;
 #[cfg(not(any(
    target_os = "linux",
    target_os = "macos",
@@ -39,6 +40,17 @@ pub mod posix;
 #[cfg(target_os = "windows")]
 pub mod windows;

+/// Host OS path for a binary artifact.
+///
+/// Backend is chosen at compile time via `cfg!(target_os = …)`, not by the build target triple.
+///
+/// # Parameters
+/// - `profile`: Build profile directory segment.
+/// - `name`: Binary basename (may already include extension on some hosts).
+/// - `target_dir`: Optional absolute/relative artifact directory override.
+///
+/// # Returns
+/// Path string suitable for the current host layout.
 pub fn bin_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
    #[cfg(target_os = "linux")]
    {
@@ -75,6 +87,9 @@ pub fn bin_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
    }
 }

+/// Host OS path for an ELF-style artifact (`profile`, `name`, optional `target_dir`).
+///
+/// Backend is chosen at compile time via `cfg!(target_os = …)`, not by the build target triple.
 pub fn elf_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
    #[cfg(target_os = "linux")]
    {
@@ -111,6 +126,9 @@ pub fn elf_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
    }
 }

+/// Host OS path for an EFI (`.efi`) artifact (`profile`, `name`, optional `target_dir`).
+///
+/// Backend is chosen at compile time via `cfg!(target_os = …)`, not by the build target triple.
 pub fn efi_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
    #[cfg(target_os = "linux")]
    {
@@ -147,6 +165,9 @@ pub fn efi_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
    }
 }

+/// Host OS path for a static library (`profile`, `name`, optional `target_dir`).
+///
+/// Backend is chosen at compile time via `cfg!(target_os = …)`, not by the build target triple.
 pub fn lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
    #[cfg(target_os = "linux")]
    {
@@ -183,6 +204,9 @@ pub fn lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
    }
 }

+/// Host OS path for a shared library (`profile`, `name`, optional `target_dir`).
+///
+/// Backend is chosen at compile time via `cfg!(target_os = …)`, not by the build target triple.
 pub fn shared_lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
    #[cfg(target_os = "linux")]
    {
--- a/src/platform/path_util.rs
+++ b/src/platform/path_util.rs
@@ -0,0 +1,87 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use std::path::{Path, PathBuf};
+
+/// Joins the given directory and file into a single path string, trimming trailing slashes
+/// for cross-platform compatibility.
+pub fn join_dir(dir: &str, file: &str) -> String {
+    let trimmed = dir.trim_end_matches(['/', '\\']);
+    Path::new(trimmed).join(file).to_string_lossy().into_owned()
+}
+
+#[cfg_attr(not(windows), allow(dead_code))]
+/// Adds `.exe` suffix to the name if it does not already have a recognized executable
+/// extension (`.exe`, `.dll`, `.sys`, `.com`, `.efi`) or any extension at all.
+pub fn with_exe_suffix(name: &str) -> String {
+    let lower = name.to_ascii_lowercase();
+    // Check if name already qualifies for no suffix (has executable ext or any ext)
+    if lower.ends_with(".exe")
+        || lower.ends_with(".dll")
+        || lower.ends_with(".sys")
+        || lower.ends_with(".com")
+        || lower.ends_with(".efi")
+        || Path::new(name).extension().is_some()
+    {
+        name.to_string()
+    } else {
+        format!("{name}.exe")
+    }
+}
+
+/// Default relative binary path: `./target[/<triple>]/<profile>/<name>`.
+pub fn default_bin_rel(profile: &str, name: &str, triple_segment: Option<&str>) -> String {
+    let mut p = PathBuf::from("./target");
+    if let Some(t) = triple_segment {
+        p = p.join(t);
+    }
+    p.join(profile).join(name).to_string_lossy().into_owned()
+}
+
+/// Default relative library path: `./target[/<triple>]/<profile>/<file>`.
+pub fn default_lib_rel(profile: &str, file: &str, triple_segment: Option<&str>) -> String {
+    let mut p = PathBuf::from("./target");
+    if let Some(t) = triple_segment {
+        p = p.join(t);
+    }
+    p.join(profile).join(file).to_string_lossy().into_owned()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn join_dir_trims_both_slashes() {
+        assert_eq!(
+            join_dir("out/", "a"),
+            Path::new("out").join("a").to_string_lossy()
+        );
+        assert_eq!(
+            join_dir(r"out\", "a"),
+            Path::new("out").join("a").to_string_lossy()
+        );
+    }
+
+    #[test]
+    fn with_exe_no_double() {
+        assert_eq!(with_exe_suffix("hello"), "hello.exe");
+        assert_eq!(with_exe_suffix("hello.exe"), "hello.exe");
+        assert_eq!(with_exe_suffix("KERNEL.ELF"), "KERNEL.ELF");
+        assert_eq!(with_exe_suffix("x.dll"), "x.dll");
+    }
+}
--- a/src/platform/posix.rs
+++ b/src/platform/posix.rs
@@ -1,31 +1,48 @@
+/// POSIX platform-specific path utilities.
+/// Provides functions to build paths for binaries, libraries, and EFI files based on profile and optional target directory.
+use super::path_util::{default_bin_rel, default_lib_rel, join_dir};
+
+/// Returns the path to a binary executable for the given profile, name, and optional target directory.
+/// If a target directory is provided, it joins the directory with the name; otherwise, it uses the default binary relative path.
 pub fn bin_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
    match target_dir {
-        Some(dir) => format!("{}/{}", dir.trim_end_matches('/'), name),
-        None => format!("./target/{profile}/{name}"),
+        Some(dir) => join_dir(dir, name),
+        None => default_bin_rel(profile, name, None),
    }
 }

+/// Returns the path to a static library for the given profile, name, and optional target directory.
+/// The library file is named "lib{name}.a". If a target directory is provided, it joins the directory with the file name; otherwise, it uses the default library relative path.
 pub fn lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    let file = format!("lib{name}.a");
    match target_dir {
-        Some(dir) => format!("{}/lib{}.a", dir.trim_end_matches('/'), name),
-        None => format!("./target/{profile}/lib{name}.a"),
+        Some(dir) => join_dir(dir, &file),
+        None => default_lib_rel(profile, &file, None),
    }
 }

+/// Returns the path to an ELF binary for the given profile, name, and optional target directory.
+/// Delegates to bin_path since ELF binaries are standard binaries.
 pub fn elf_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
    bin_path(profile, name, target_dir)
 }

+/// Returns the path to an EFI executable for the given profile, name, and optional target directory.
+/// The EFI file is named "{name}.efi". If a target directory is provided, it joins the directory with the file name; otherwise, it uses the default library relative path.
 pub fn efi_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    let file = format!("{name}.efi");
    match target_dir {
-        Some(dir) => format!("{}/{}.efi", dir.trim_end_matches('/'), name),
-        None => format!("./target/{profile}/{name}.efi"),
+        Some(dir) => join_dir(dir, &file),
+        None => default_lib_rel(profile, &file, None),
    }
 }

+/// Returns the path to a shared library for the given profile, name, and optional target directory.
+/// The shared library file is named "lib{name}.so". If a target directory is provided, it joins the directory with the file name; otherwise, it uses the default library relative path.
 pub fn shared_lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    let file = format!("lib{name}.so");
    match target_dir {
-        Some(dir) => format!("{}/lib{}.so", dir.trim_end_matches('/'), name),
-        None => format!("./target/{profile}/lib{name}.so"),
+        Some(dir) => join_dir(dir, &file),
+        None => default_lib_rel(profile, &file, None),
    }
 }
--- a/src/platform/windows.rs
+++ b/src/platform/windows.rs
@@ -15,37 +15,63 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.

+use super::path_util::{default_bin_rel, default_lib_rel, join_dir, with_exe_suffix};
+
+/// Returns the path to the binary executable for the given profile, name, and optional target directory.
 pub fn bin_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    let file = with_exe_suffix(name);
    match target_dir {
-        Some(dir) => format!("{}/{}.exe", dir.trim_end_matches('/'), name),
-        None => format!("./target/{profile}/{name}.exe"),
+        Some(dir) => join_dir(dir, &file),
+        None => default_bin_rel(profile, &file, None),
    }
 }

+/// Returns the path to the library file for the given profile, name, and optional target directory.
+/// The library name is forced to end with ".lib".
 pub fn lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    // Ensure the library file name ends with ".lib"
+    let file = if name.to_ascii_lowercase().ends_with(".lib") {
+        name.to_string()
+    } else {
+        format!("{name}.lib")
+    };
    match target_dir {
-        Some(dir) => format!("{}/{}.lib", dir.trim_end_matches('/'), name),
-        None => format!("./target/{profile}/{name}.lib"),
+        Some(dir) => join_dir(dir, &file),
+        None => default_lib_rel(profile, &file, None),
    }
 }

+/// Returns the path to the ELF binary for the given profile, name, and optional target directory.
 pub fn elf_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
-    match target_dir {
-        Some(dir) => format!("{}/{}.exe", dir.trim_end_matches('/'), name),
-        None => format!("./target/{profile}/{name}.exe"),
-    }
+    bin_path(profile, name, target_dir)
 }

+/// Returns the path to the EFI binary for the given profile, name, and optional target directory.
+/// The binary name is forced to end with ".efi".
 pub fn efi_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    // Ensure the EFI file name ends with ".efi"
+    let file = if name.to_ascii_lowercase().ends_with(".efi") {
+        name.to_string()
+    } else {
+        format!("{name}.efi")
+    };
    match target_dir {
-        Some(dir) => format!("{}/{}.efi", dir.trim_end_matches('/'), name),
-        None => format!("./target/{profile}/{name}.efi"),
+        Some(dir) => join_dir(dir, &file),
+        None => default_lib_rel(profile, &file, None),
    }
 }

+/// Returns the path to the shared library (DLL) for the given profile, name, and optional target directory.
+/// The library name is forced to end with ".dll".
 pub fn shared_lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    // Ensure the shared library file name ends with ".dll"
+    let file = if name.to_ascii_lowercase().ends_with(".dll") {
+        name.to_string()
+    } else {
+        format!("{name}.dll")
+    };
    match target_dir {
-        Some(dir) => format!("{}/{}.dll", dir.trim_end_matches('/'), name),
-        None => format!("./target/{profile}/{name}.dll"),
+        Some(dir) => join_dir(dir, &file),
+        None => default_lib_rel(profile, &file, None),
    }
 }
--- a/src/utils/build.rs
+++ b/src/utils/build.rs
@@ -17,7 +17,11 @@

 use crate::core::build_config::Config;
 use crate::utils::log::warn;
+use std::path::{Path, PathBuf};

+/// Version information parsed from a version string.
+///
+/// Contains the full version, major, minor, patch, suffix, and suffix_dash components.
 pub struct VersionInfo {
    pub full: String,
    pub major: String,
@@ -27,6 +31,40 @@ pub struct VersionInfo {
    pub suffix_dash: String,
 }

+/// Compares two semver-like strings (`X.Y.Z` with optional `-suffix`, suffix ignored).
+///
+/// Returns `None` if either side has no parseable numeric major component.
+/// Ordering is tool-centric: `compare_semver(tool, required)` → `Less` means tool is older.
+pub fn compare_semver(left: &str, right: &str) -> Option<std::cmp::Ordering> {
+    let l = semver_numeric_parts(left)?;
+    let r = semver_numeric_parts(right)?;
+    Some(l.cmp(&r))
+}
+
+fn semver_numeric_parts(version: &str) -> Option<(u64, u64, u64)> {
+    let base = version
+        .trim()
+        .split_once('-')
+        .map(|(h, _)| h)
+        .unwrap_or(version.trim());
+    if base.is_empty() {
+        return None;
+    }
+    let mut parts = base.split('.');
+    let major = parts.next()?.parse::<u64>().ok()?;
+    let minor = parts.next().unwrap_or("0").parse::<u64>().unwrap_or(0);
+    let patch = parts
+        .next()
+        .unwrap_or("0")
+        .chars()
+        .take_while(|c| c.is_ascii_digit())
+        .collect::<String>()
+        .parse::<u64>()
+        .unwrap_or(0);
+    Some((major, minor, patch))
+}
+
+/// Parses a version string into VersionInfo struct.
 pub fn parse_version_info(version: &str) -> VersionInfo {
    let mut full = version.trim().to_string();
    if full.is_empty() {
@@ -55,6 +93,7 @@ pub fn parse_version_info(version: &str) -> VersionInfo {
    }
 }

+/// Substitutes profile, name, and version variables into a template string.
 pub fn substitute_vars(template: &str, info: &VersionInfo, profile: &str, name: &str) -> String {
    let s = template
        .replace("{profile}", profile)
@@ -62,6 +101,7 @@ pub fn substitute_vars(template: &str, info: &VersionInfo, profile: &str, name:
    substitute_version_vars(&s, info)
 }

+/// Substitutes version-specific variables into a template string.
 pub fn substitute_version_vars(template: &str, info: &VersionInfo) -> String {
    template
        .replace("{version}", &info.full)
@@ -72,6 +112,7 @@ pub fn substitute_version_vars(template: &str, info: &VersionInfo) -> String {
        .replace("{version_suffix_dash}", &info.suffix_dash)
 }

+/// Normalizes a target string to a relative path for artifact output directory.
 pub fn normalize_target(target: &str, profile: &str) -> Option<String> {
    let trimmed = normalize_target_os(target.trim());
    if trimmed.is_empty() {
@@ -81,11 +122,111 @@ pub fn normalize_target(target: &str, profile: &str) -> Option<String> {
    }
 }

+/// Returns the native host target directory relative to project root for given profile.
+pub fn native_host_target_rel(profile: &str) -> PathBuf {
+    if cfg!(any(
+        target_os = "linux",
+        target_os = "freebsd",
+        target_os = "openbsd",
+        target_os = "netbsd",
+        target_os = "dragonfly"
+    )) {
+        Path::new("target")
+            .join(default_target_triple())
+            .join(profile)
+    } else {
+        Path::new("target").join(profile)
+    }
+}
+
+/// Resolves the artifact output directory for a project/workspace build.
+///
+/// # Parameters
+/// - `project_root`: Package root.
+/// - `workspace_root`: If set, artifacts go under the workspace `target/`.
+/// - `profile`: Build profile directory segment.
+/// - `build_target`: Target triple or short name (may be empty).
+/// - `out_dir`: Explicit `out_dir` from config (wins when non-empty).
+/// - `has_explicit_target`: Whether CLI/config set a target (changes layout).
+///
+/// # Returns
+/// Absolute directory path as a string.
+pub fn resolve_artifact_target_dir(
+    project_root: &Path,
+    workspace_root: Option<&Path>,
+    profile: &str,
+    build_target: &str,
+    out_dir: &str,
+    has_explicit_target: bool,
+) -> String {
+    if !out_dir.trim().is_empty() {
+        let p = Path::new(out_dir.trim());
+        return if p.is_absolute() {
+            out_dir.trim().to_string()
+        } else {
+            project_root.join(p).to_string_lossy().into_owned()
+        };
+    }
+
+    if let Some(ws) = workspace_root {
+        let triple = if build_target.trim().is_empty() {
+            default_target_triple()
+        } else {
+            let n = normalize_target_os(build_target.trim());
+            if n.is_empty() {
+                default_target_triple()
+            } else {
+                n.to_string()
+            }
+        };
+        return ws
+            .join("target")
+            .join(triple)
+            .join(profile)
+            .to_string_lossy()
+            .into_owned();
+    }
+
+    let base = if has_explicit_target {
+        match normalize_target(build_target, profile) {
+            Some(rel) => PathBuf::from(rel),
+            None => native_host_target_rel(profile),
+        }
+    } else {
+        native_host_target_rel(profile)
+    };
+    project_root.join(base).to_string_lossy().into_owned()
+}
+
+/// Normalizes kind string to standard value, defaulting to "bin" if empty.
 pub fn normalize_kind(kind: &str) -> &str {
    let trimmed = kind.trim();
    if trimmed.is_empty() { "bin" } else { trimmed }
 }

+/// Checks if the kind is a flat binary artifact.
+pub fn is_flat_bin(kind: &str) -> bool {
+    kind == "flat-bin"
+}
+
+/// Returns true for kinds that skip the normal link/archive step: `none`, `custom`, or `flat-bin`.
+///
+/// Callers that still need a flat-binary path use [`is_flat_bin`] separately
+/// (e.g. `is_compile_only(kind) && !is_flat_bin(kind)` before an early return).
+///
+/// # Parameters
+/// - `kind`: Normalized artifact kind string.
+///
+/// # Returns
+/// `true` for `none`, `custom`, or `flat-bin`.
+///
+/// Callers that still need a flat-binary link use [`is_flat_bin`] separately
+/// (e.g. `is_compile_only(kind) && !is_flat_bin(kind)` before early return).
+pub fn is_compile_only(kind: &str) -> bool {
+    matches!(kind, "none" | "custom" | "flat-bin")
+}
+
+/// Normalizes platform string, returning None if empty.
 pub fn normalize_platform(platform: &str) -> Option<&str> {
    let trimmed = platform.trim();
    if trimmed.is_empty() {
@@ -95,8 +236,16 @@ pub fn normalize_platform(platform: &str) -> Option<&str> {
    }
 }

+/// Expands short OS names (`linux`/`macos`/`windows`) to default triples; leaves others as-is.
+///
+/// # Parameters
+/// - `target`: Short name, full triple, or empty.
+///
+/// # Returns
+/// Canonical triple string, empty input unchanged, unknown bare names returned with a warning.
 pub fn normalize_target_os(target: &str) -> &str {
    match target {
+        "" => "",
        "linux" => "x86_64-unknown-linux-gnu",
        "macos" => "x86_64-apple-darwin",
        "windows" => "x86_64-pc-windows-msvc",
@@ -111,6 +260,7 @@ pub fn normalize_target_os(target: &str) -> &str {
    }
 }

+/// Returns the default target triple for the current host platform.
 pub fn default_target_triple() -> String {
    let arch = std::env::consts::ARCH;
    if cfg!(target_os = "linux") {
@@ -141,6 +291,7 @@ pub fn default_target_triple() -> String {
    }
 }

+/// Prepends a --target flag to flags vector if using Clang and not already present.
 pub fn prepend_clang_target_flag(flags: &mut Vec<String>, target: Option<&str>, tool: &str) {
    let Some(target) = target.map(str::trim).filter(|t| !t.is_empty()) else {
        return;
@@ -158,6 +309,7 @@ pub fn prepend_clang_target_flag(flags: &mut Vec<String>, target: Option<&str>,
    }
 }

+/// Retrieves a string value from config, falling back to empty string if missing.
 pub fn get_config_str(config: &Config, key: &str) -> String {
    config
        .get(key)
@@ -166,6 +318,7 @@ pub fn get_config_str(config: &Config, key: &str) -> String {
        .to_string()
 }

+/// Retrieves profile-specific table from config.
 pub fn profile_table<'a>(config: &'a Config, profile: &str) -> Option<&'a toml::value::Table> {
    config
        .get("build")
@@ -174,6 +327,7 @@ pub fn profile_table<'a>(config: &'a Config, profile: &str) -> Option<&'a toml::
        .and_then(|v| v.as_table())
 }

+/// Retrieves an optional string value from config.
 pub fn get_config_opt(config: &Config, key: &str) -> Option<String> {
    let value = config.get(key)?.as_str()?;
    let trimmed = value.trim();
@@ -184,6 +338,7 @@ pub fn get_config_opt(config: &Config, key: &str) -> Option<String> {
    }
 }

+/// Retrieves string value with profile override support.
 pub fn get_string_with_profile(config: &Config, field: &str, profile: &str) -> String {
    let base = get_config_str(config, &format!("build.{field}"));
    let Some(table) = profile_table(config, profile) else {
@@ -198,6 +353,7 @@ pub fn get_string_with_profile(config: &Config, field: &str, profile: &str) -> S
    }
 }

+/// Retrieves list value from config.
 pub fn get_config_list(config: &Config, key: &str) -> Vec<String> {
    config
        .get(key)
@@ -211,6 +367,7 @@ pub fn get_config_list(config: &Config, key: &str) -> Vec<String> {
        .unwrap_or_default()
 }

+/// Retrieves list value with profile override support.
 pub fn get_list_with_profile(config: &Config, field: &str, profile: &str) -> Vec<String> {
    let mut out = get_config_list(config, &format!("build.{field}"));
    if let Some(table) = profile_table(config, profile)
@@ -226,6 +383,7 @@ pub fn get_list_with_profile(config: &Config, field: &str, profile: &str) -> Vec
    out
 }

+/// Helper function to check if a string contains a pattern ignoring case.
 fn contains_ignore_case(text: &str, pattern: &str) -> bool {
    if pattern.len() > text.len() {
        return false;
@@ -235,6 +393,7 @@ fn contains_ignore_case(text: &str, pattern: &str) -> bool {
        .any(|w| w.eq_ignore_ascii_case(pattern.as_bytes()))
 }

+/// Checks if target is a bare-metal or embedded target.
 pub fn is_bare_metal_target(target: Option<&str>) -> bool {
    match target {
        Some(t) => {
@@ -248,6 +407,7 @@ pub fn is_bare_metal_target(target: Option<&str>) -> bool {
    }
 }

+/// Returns default flags for a given profile.
 pub fn default_profile_flags(profile: &str) -> &'static [&'static str] {
    match profile {
        "release" => &["-O3", "-DNDEBUG"],
@@ -263,6 +423,7 @@ pub fn default_profile_flags(profile: &str) -> &'static [&'static str] {
    }
 }

+/// Retrieves boolean value with profile override support.
 pub fn get_bool_with_profile(config: &Config, field: &str, profile: &str, default: bool) -> bool {
    let base = config
        .get(&format!("build.{field}"))
@@ -272,6 +433,7 @@ pub fn get_bool_with_profile(config: &Config, field: &str, profile: &str, defaul
    profile_val.or(base).unwrap_or(default)
 }

+/// Retrieves language from config with profile support.
 pub fn get_language_with_profile(config: &Config, profile: &str) -> Result<String, String> {
    if let Some(table) = profile_table(config, profile)
        && let Some(value) = table.get("language")
@@ -284,10 +446,12 @@ pub fn get_language_with_profile(config: &Config, profile: &str) -> Result<Strin
    }
 }

+/// Retrieves language from config with profile support, defaulting to "c" on error.
 pub fn get_language_with_profile_or_default(config: &Config, profile: &str) -> String {
    get_language_with_profile(config, profile).unwrap_or_else(|_| "c".to_string())
 }

+/// Parses language value from config, supporting string or array format.
 pub fn parse_language_value(value: &toml::Value, key: &str) -> Result<String, String> {
    if let Some(s) = value.as_str() {
        let trimmed = s.trim();
@@ -316,6 +480,7 @@ pub fn parse_language_value(value: &toml::Value, key: &str) -> Result<String, St
    Ok(parts.join(","))
 }

+/// Resolves compiler name based on language, environment, and toolchain overrides.
 pub fn resolve_compiler(
    language: &str,
    compiler: &str,
@@ -334,6 +499,7 @@ pub fn resolve_compiler(
    }
 }

+/// Checks environment variables for compiler override.
 fn env_override_compiler(lang: &str) -> Option<String> {
    if let Ok(value) = std::env::var("DCR_COMPILER") {
        let trimmed = value.trim();
@@ -367,6 +533,7 @@ fn env_override_compiler(lang: &str) -> Option<String> {
    None
 }

+/// Checks toolchain overrides for compiler.
 fn toolchain_override_compiler(
    lang: &str,
    tc_cc: Option<&str>,
@@ -385,6 +552,7 @@ fn toolchain_override_compiler(
    tc_cc.map(|v| v.to_string())
 }

+/// Maps assembler compiler name to canonical form.
 fn map_asm_compiler(compiler: &str) -> String {
    match compiler.to_lowercase().as_str() {
        "gas" | "gnu-as" => "as".to_string(),
@@ -395,6 +563,7 @@ fn map_asm_compiler(compiler: &str) -> String {
    }
 }

+/// Determines primary language from comma-separated list.
 pub fn primary_language(language: &str) -> String {
    let tokens: Vec<&str> = language
        .split(',')
@@ -413,6 +582,7 @@ pub fn primary_language(language: &str) -> String {
    language.to_lowercase()
 }

+/// Resolves tool from environment variable or fallback.
 pub fn resolve_tool(env_key: &str, fallback: Option<&str>) -> Option<String> {
    if let Ok(value) = std::env::var(env_key) {
        let trimmed = value.trim();
@@ -423,6 +593,7 @@ pub fn resolve_tool(env_key: &str, fallback: Option<&str>) -> Option<String> {
    fallback.map(|v| v.to_string())
 }

+/// Resolves pkg-config flags for packages.
 pub fn resolve_pkg_config_flags(
    pkgs: &[String],
    base_cflags: &[String],
@@ -439,6 +610,7 @@ pub fn resolve_pkg_config_flags(
    Ok((cflags, ldflags))
 }

+/// Resolves pkg-config flags, falling back on error.
 pub fn resolve_pkg_config_flags_lossy(
    pkgs: &[String],
    base_cflags: &[String],
@@ -453,6 +625,7 @@ pub fn resolve_pkg_config_flags_lossy(
    }
 }

+/// Runs pkg-config command and returns output.
 pub fn run_pkg_config(pkg: &str, arg: &str) -> Result<String, String> {
    let output = std::process::Command::new("pkg-config")
        .arg(arg)
@@ -466,6 +639,7 @@ pub fn run_pkg_config(pkg: &str, arg: &str) -> Result<String, String> {
    Ok(String::from_utf8_lossy(&output.stdout).to_string())
 }

+// The split_flags function parses pkg-config output, handling quoted strings and whitespace to split into individual flags.
 fn split_flags(value: &str) -> Vec<String> {
    let mut out = Vec::new();
    let mut current = String::new();
@@ -505,8 +679,10 @@ fn split_flags(value: &str) -> Vec<String> {
 mod tests {
    use super::*;

+    /// Test for normalize_target_short_names function.
    #[test]
    fn normalize_target_short_names() {
+        assert_eq!(normalize_target_os(""), "");
        assert_eq!(normalize_target_os("linux"), "x86_64-unknown-linux-gnu");
        assert_eq!(normalize_target_os("macos"), "x86_64-apple-darwin");
        assert_eq!(normalize_target_os("windows"), "x86_64-pc-windows-msvc");
@@ -517,20 +693,31 @@ mod tests {
        assert_eq!(normalize_target_os("unknown"), "unknown");
    }

+    /// Test for default_target_triple_uses_host_arch function.
    #[test]
    fn default_target_triple_uses_host_arch() {
        let target = default_target_triple();
        if cfg!(target_os = "linux") {
+            let env = if cfg!(target_env = "musl") {
+                "musl"
+            } else {
+                "gnu"
+            };
            assert_eq!(
                target,
-                format!("{}-unknown-linux-gnu", std::env::consts::ARCH)
+                format!("{}-unknown-linux-{env}", std::env::consts::ARCH)
            );
        } else if cfg!(target_os = "macos") {
            assert_eq!(target, format!("{}-apple-darwin", std::env::consts::ARCH));
        } else if cfg!(target_os = "windows") {
+            let env = if cfg!(target_env = "gnu") {
+                "gnu"
+            } else {
+                "msvc"
+            };
            assert_eq!(
                target,
-                format!("{}-pc-windows-msvc", std::env::consts::ARCH)
+                format!("{}-pc-windows-{env}", std::env::consts::ARCH)
            );
        } else if cfg!(any(
            target_os = "freebsd",
@@ -551,6 +738,28 @@ mod tests {
        }
    }

+    /// Test for resolve_artifact_target_dir_native_and_workspace function.
+    #[test]
+    fn resolve_artifact_target_dir_native_and_workspace() {
+        let root = Path::new("/proj");
+        let ws = Path::new("/ws");
+        let host = default_target_triple();
+        let native = resolve_artifact_target_dir(root, None, "debug", &host, "", false);
+        let expected_native = root.join(native_host_target_rel("debug"));
+        assert_eq!(native, expected_native.to_string_lossy());
+
+        let explicit =
+            resolve_artifact_target_dir(root, None, "debug", "x86_64-unknown-linux-gnu", "", true);
+        assert!(explicit.contains("x86_64-unknown-linux-gnu"));
+
+        let ws_dir = resolve_artifact_target_dir(root, Some(ws), "debug", &host, "", false);
+        assert!(ws_dir.starts_with("/ws") || ws_dir.contains("ws"));
+        assert!(ws_dir.contains(&host) || cfg!(windows));
+        let out = resolve_artifact_target_dir(root, None, "debug", "", "dist", false);
+        assert!(out.contains("dist"));
+    }
+
+    /// Test for prepend_clang_target_flag_adds_once_for_clang function.
    #[test]
    fn prepend_clang_target_flag_adds_once_for_clang() {
        let mut flags = vec!["-O2".to_string()];
@@ -565,6 +774,7 @@ mod tests {
        );
    }

+    /// Test for prepend_clang_target_flag_ignores_non_clang_tools function.
    #[test]
    fn prepend_clang_target_flag_ignores_non_clang_tools() {
        let mut flags = vec!["-O2".to_string()];
@@ -572,6 +782,7 @@ mod tests {
        assert_eq!(flags, vec!["-O2".to_string()]);
    }

+    /// Test for parse_version_parts function.
    #[test]
    fn parse_version_parts() {
        let info = parse_version_info("1.2.3-beta");
@@ -583,19 +794,32 @@ mod tests {
        assert_eq!(info.suffix_dash, "-beta");
    }

+    #[test]
+    fn compare_semver_orders_and_ignores_prerelease() {
+        use std::cmp::Ordering;
+        assert_eq!(compare_semver("0.8.4", "0.8.4"), Some(Ordering::Equal));
+        assert_eq!(compare_semver("0.8.3", "0.8.4"), Some(Ordering::Less));
+        assert_eq!(compare_semver("0.9.0", "0.8.4"), Some(Ordering::Greater));
+        assert_eq!(compare_semver("1.0.0-dev", "1.0.0"), Some(Ordering::Equal));
+        assert_eq!(compare_semver("not-a-version", "0.1.0"), None);
+    }
+
+    /// Test for normalize_target_with_profile function.
    #[test]
    fn normalize_target_with_profile() {
+        let linux = normalize_target_os("linux");
        assert_eq!(
            normalize_target("linux", "debug"),
-            Some("target/x86_64-unknown-linux-gnu/debug".into())
+            Some(format!("target/{linux}/debug"))
        );
        assert_eq!(
-            normalize_target("x86_64-unknown-linux-gnu", "release"),
-            Some("target/x86_64-unknown-linux-gnu/release".into())
+            normalize_target(linux, "release"),
+            Some(format!("target/{linux}/release"))
        );
        assert_eq!(normalize_target("", "debug"), None);
    }

+    /// Test for normalize_kind_empty_defaults_to_bin function.
    #[test]
    fn normalize_kind_empty_defaults_to_bin() {
        assert_eq!(normalize_kind(""), "bin");
@@ -604,6 +828,7 @@ mod tests {
        assert_eq!(normalize_kind("  elf  "), "elf");
    }

+    /// Test for normalize_platform_empty_is_none function.
    #[test]
    fn normalize_platform_empty_is_none() {
        assert_eq!(normalize_platform(""), None);
@@ -612,6 +837,7 @@ mod tests {
        assert_eq!(normalize_platform(" efi "), Some("efi"));
    }

+    /// Test for default_profile_flags_by_profile function.
    #[test]
    fn default_profile_flags_by_profile() {
        assert!(default_profile_flags("debug").contains(&"-O0"));
@@ -621,6 +847,7 @@ mod tests {
        assert!(default_profile_flags("unknown").is_empty());
    }

+    /// Test for is_bare_metal_detects_embedded_targets function.
    #[test]
    fn is_bare_metal_detects_embedded_targets() {
        assert!(is_bare_metal_target(Some("aarch64-none-elf")));
--- a/src/utils/fs.rs
+++ b/src/utils/fs.rs
@@ -16,8 +16,13 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.

 use std::io;
+use std::io::Write;
 use std::path::{Path, PathBuf};

+/// Resolves the path to the user's home directory across different operating systems.
+///
+/// Checks the `HOME` environment variable (Unix-like systems) first,
+/// then falls back to `USERPROFILE` (Windows).
 pub fn home_dir() -> Option<PathBuf> {
    if let Ok(home) = std::env::var("HOME") {
        return Some(PathBuf::from(home));
@@ -28,6 +33,7 @@ pub fn home_dir() -> Option<PathBuf> {
    None
 }

+/// Converts a byte slice into a lowercase hexadecimal string.
 pub fn to_hex(bytes: &[u8]) -> String {
    let mut out = String::with_capacity(bytes.len() * 2);
    for b in bytes {
@@ -36,6 +42,7 @@ pub fn to_hex(bytes: &[u8]) -> String {
    out
 }

+/// Lists all entry names (files and directories) inside a target directory.
 #[allow(dead_code)]
 pub fn check_dir(dir: Option<&str>) -> io::Result<Vec<String>> {
    let path: PathBuf = match dir {
@@ -52,6 +59,7 @@ pub fn check_dir(dir: Option<&str>) -> io::Result<Vec<String>> {
    Ok(items)
 }

+/// Searches upwards from a starting path to locate the root directory containing `dcr.toml`.
 pub fn find_project_root(start: &Path) -> io::Result<Option<PathBuf>> {
    let mut current = start.to_path_buf();
    loop {
@@ -65,6 +73,15 @@ pub fn find_project_root(start: &Path) -> io::Result<Option<PathBuf>> {
    Ok(None)
 }

+/// Executes a closure inside a specified directory and restores the original cwd afterwards.
+///
+/// # Parameters
+/// - `dir`: Directory to `cd` into for the duration of `f`.
+/// - `f`: Work to run with that cwd (its `Result` is returned as-is).
+///
+/// # Returns
+/// The closure's result, or an error if getting/changing directory fails.
+/// Cwd is restored even when `f` returns `Err`.
 pub fn with_dir<F, T>(dir: &Path, f: F) -> Result<T, String>
 where
    F: FnOnce() -> Result<T, String>,
@@ -72,6 +89,178 @@ where
    let prev = std::env::current_dir().map_err(|_| "Failed to get current dir".to_string())?;
    std::env::set_current_dir(dir).map_err(|_| "Failed to change directory".to_string())?;
    let result = f();
+    // Restore previous working directory regardless of closure result.
    let _ = std::env::set_current_dir(prev);
    result
 }
+
+/// Strips Windows verbatim/extended-length prefixes (e.g. `\\?\`, `\\.\`) and standardizes slashes.
+///
+/// Normalize path separators for cross-platform safety and removes platform-specific extended prefixes.
+pub fn strip_verbatim_prefix(path: PathBuf) -> PathBuf {
+    let s = path.to_string_lossy();
+    let mut cleaned = s.replace('\\', "/");
+    if let Some(rest) = cleaned.strip_prefix("//?/") {
+        cleaned = rest.to_string();
+    } else if let Some(rest) = cleaned.strip_prefix("//./") {
+        cleaned = rest.to_string();
+    } else if let Some(rest) = cleaned.strip_prefix(r"\\?\") {
+        cleaned = rest.replace('\\', "/");
+    } else if let Some(rest) = cleaned.strip_prefix(r"\\.\") {
+        cleaned = rest.replace('\\', "/");
+    }
+    if cleaned.len() >= 3 && cleaned.as_bytes()[0] == b'/' && cleaned.as_bytes()[2] == b':' {
+        cleaned = cleaned[1..].to_string();
+    }
+    if cfg!(windows) {
+        PathBuf::from(cleaned.replace('/', "\\"))
+    } else {
+        PathBuf::from(cleaned)
+    }
+}
+
+/// Canonicalizes a path to its absolute form and cleans up Windows extended-length prefixes.
+///
+/// Falls back to joining relative paths with the current working directory if canonicalization fails.
+pub fn canonicalize_path(path: &Path) -> PathBuf {
+    let raw = std::fs::canonicalize(path).unwrap_or_else(|_| {
+        if path.is_absolute() {
+            path.to_path_buf()
+        } else {
+            std::env::current_dir()
+                .map(|cwd| cwd.join(path))
+                .unwrap_or_else(|_| path.to_path_buf())
+        }
+    });
+    strip_verbatim_prefix(raw)
+}
+
+/// Resolves a path relative to a root directory and returns a canonicalized absolute path.
+pub fn absolute_join(root: &Path, path: &Path) -> PathBuf {
+    let joined = if path.is_absolute() {
+        path.to_path_buf()
+    } else {
+        root.join(path)
+    };
+    canonicalize_path(&joined)
+}
+
+/// Ensures the `.dcr` internal metadata directory and its `ide` subfolder exist within a project root.
+pub fn ensure_dcr_dir(root: &Path) -> io::Result<PathBuf> {
+    let dcr = root.join(".dcr");
+    std::fs::create_dir_all(dcr.join("ide"))?;
+    Ok(dcr)
+}
+
+/// Writes `contents` via a `.tmp.<pid>` file then renames into place (best-effort replace).
+///
+/// # Parameters
+/// - `path`: Final destination path (parent dirs are created).
+/// - `contents`: Bytes to write.
+///
+/// # Returns
+/// `Ok(())` after a successful rename (with fallbacks if the target already exists).
+pub fn atomic_write(path: &Path, contents: impl AsRef<[u8]>) -> io::Result<()> {
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent)?;
+    }
+    let pid = std::process::id();
+    let file_name = path
+        .file_name()
+        .map(|n| n.to_string_lossy().into_owned())
+        .unwrap_or_else(|| "tmp".to_string());
+    let tmp = path.with_file_name(format!("{file_name}.tmp.{pid}"));
+    {
+        let mut f = std::fs::File::create(&tmp)?;
+        f.write_all(contents.as_ref())?;
+        let _ = f.sync_all();
+    }
+    match std::fs::rename(&tmp, path) {
+        Ok(()) => Ok(()),
+        Err(e) => {
+            // Handle cross-device moves or existing file replacement fallbacks.
+            if path.exists() {
+                let _ = std::fs::remove_file(path);
+                match std::fs::rename(&tmp, path) {
+                    Ok(()) => Ok(()),
+                    Err(e2) => {
+                        let _ = std::fs::remove_file(&tmp);
+                        Err(e2)
+                    }
+                }
+            } else {
+                let _ = std::fs::remove_file(&tmp);
+                Err(e)
+            }
+        }
+    }
+}
+
+/// Ensures that `.gitignore` exists in the project directory and includes the `.dcr/` output rule.
+///
+/// If `.gitignore` does not exist, creates one with standard `/target` and `.dcr/` entries.
+pub fn ensure_gitignore_has_dcr(project_dir: &Path) -> io::Result<()> {
+    let path = project_dir.join(".gitignore");
+    if path.exists() {
+        let content = std::fs::read_to_string(&path)?;
+        let has = content.lines().any(|l| {
+            let t = l.trim();
+            t == ".dcr/" || t == ".dcr" || t == "/.dcr/" || t == "/.dcr"
+        });
+        if !has {
+            let mut new_content = content;
+            if !new_content.ends_with('\n') && !new_content.is_empty() {
+                new_content.push('\n');
+            }
+            new_content.push_str(".dcr/\n");
+            std::fs::write(&path, new_content)?;
+        }
+    } else {
+        std::fs::write(&path, "/target\n.dcr/\n")?;
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+
+    #[test]
+    fn canonicalize_path_absolute() {
+        let cwd = std::env::current_dir().unwrap();
+        let got = canonicalize_path(&cwd);
+        assert!(got.is_absolute());
+    }
+
+    #[test]
+    fn canonicalize_path_relative_fallback() {
+        let p = Path::new("does-not-exist-xyz-12345");
+        let got = canonicalize_path(p);
+        assert!(got.is_absolute());
+    }
+
+    #[test]
+    fn atomic_write_roundtrip() {
+        let dir = std::env::temp_dir().join(format!("dcr_atomic_{}", std::process::id()));
+        let _ = fs::remove_dir_all(&dir);
+        fs::create_dir_all(&dir).unwrap();
+        let path = dir.join("out.json");
+        atomic_write(&path, b"hello").unwrap();
+        assert_eq!(fs::read_to_string(&path).unwrap(), "hello");
+        atomic_write(&path, b"world").unwrap();
+        assert_eq!(fs::read_to_string(&path).unwrap(), "world");
+        let _ = fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn ensure_dcr_dir_creates_ide() {
+        let dir = std::env::temp_dir().join(format!("dcr_dir_{}", std::process::id()));
+        let _ = fs::remove_dir_all(&dir);
+        fs::create_dir_all(&dir).unwrap();
+        let dcr = ensure_dcr_dir(&dir).unwrap();
+        assert!(dcr.is_dir());
+        assert!(dcr.join("ide").is_dir());
+        let _ = fs::remove_dir_all(&dir);
+    }
+}
--- a/src/utils/git.rs
+++ b/src/utils/git.rs
@@ -1,6 +1,9 @@
 use std::path::Path;
 use std::process::Command;

+/// Checks if the `git` executable is available in the system's PATH.
+///
+/// This function executes `git --version` and returns `true` if the command succeeds, `false` otherwise.
 pub fn is_git_available() -> bool {
    Command::new("git")
        .arg("--version")
@@ -9,6 +12,7 @@ pub fn is_git_available() -> bool {
        .unwrap_or(false)
 }

+/// Initializes a new Git repository at the specified path.
 pub fn git_init(path: &Path) -> Result<(), String> {
    if !is_git_available() {
        return Err("git executable not found in PATH".to_string());
--- a/src/utils/log.rs
+++ b/src/utils/log.rs
@@ -15,27 +15,17 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.

-use crate::utils::text::{BOLD_CYAN, colored};
+use crate::utils::text::{BOLD_RED, BOLD_YELLOW, colored};

+/// Logs an error message to the standard error stream.
+///
+/// The message is prefixed with a red "error" label for visibility.
 #[allow(dead_code)]
 pub fn error(msg: &str) {
-    println!("{}: {msg}", colored("error", BOLD_CYAN),);
+    eprintln!("{}: {msg}", colored("error", BOLD_RED));
 }

 #[allow(dead_code)]
 pub fn warn(msg: &str) {
-    println!("{}: {msg}", colored("warn", BOLD_CYAN),);
+    eprintln!("{}: {msg}", colored("warn", BOLD_YELLOW));
 }
-
-// #[allow(dead_code)]
-// pub fn info(msg: &str) {
-//     println!("{}: {msg}", colored("info", BOLD));
-// }
-//
-// #[allow(dead_code)]
-// pub fn ok(msg: &str) {
-//     println!(
-//         "{}: {msg}",
-//         colored("ok", &(BRIGHT_GREEN.to_owned() + BOLD))
-//     );
-// }
--- a/src/utils/mod.rs
+++ b/src/utils/mod.rs
@@ -14,9 +14,19 @@
 //
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
+//

+/// Core utilities module providing access to build, filesystem, git, log, and text helpers.
 pub mod build;
+
+/// File system path utilities and operations.
 pub mod fs;
+
+/// Git version control system integration.
 pub mod git;
+
+/// Logging utilities for application events and debugging.
 pub mod log;
+
+/// Text processing and manipulation helpers.
 pub mod text;
--- a/src/utils/text.rs
+++ b/src/utils/text.rs
@@ -38,11 +38,15 @@ pub const BOLD_YELLOW: &str = "\x1b[1m\x1b[93m";
 #[allow(dead_code)]
 pub const BOLD_CYAN: &str = "\x1b[1m\x1b[96m";

+/// Applies ANSI escape codes to format the message with the given style.
+///
+/// This is a utility for colored output in terminal applications.
 #[allow(dead_code)]
 pub fn colored(msg: &str, style: &str) -> String {
    format!("{style}{msg}{RESET}")
 }

+/// Prints `msg` to stdout with the given ANSI `style`.
 #[allow(dead_code)]
 pub fn printc(msg: &str, style: &str) {
    println!("{style}{msg}{RESET}");
--- a/tests/cli_build.rs
+++ b/tests/cli_build.rs
@@ -77,19 +77,56 @@ fn build_run_clean_flags_normal_project() {
    assert!(out.status.success(), "dcr build --release should succeed");

    let out = run_dcr_env(&["run"], &dir, &envs);
-    let stdout = String::from_utf8_lossy(&out.stdout);
-    assert!(stdout.contains("Running"), "dcr run should start");
+    let combined = format!(
+        "{}{}",
+        String::from_utf8_lossy(&out.stdout),
+        String::from_utf8_lossy(&out.stderr)
+    );
+    assert!(
+        combined.contains("run") || combined.contains("Running"),
+        "dcr run should start"
+    );
+
+    std::fs::write(
+        dir.join("src/main.c"),
+        r#"#include <stdio.h>
+int main(int argc, char **argv) {
+    for (int i = 1; i < argc; i++) {
+        printf("ARG:%s\n", argv[i]);
+    }
+    return 0;
+}
+"#,
+    )
+    .expect("rewrite main.c");
+    let out = run_dcr_env(&["run", "--force", "--", "--test_help", "foo"], &dir, &envs);
+    let combined = format!(
+        "{}{}",
+        String::from_utf8_lossy(&out.stdout),
+        String::from_utf8_lossy(&out.stderr)
+    );
+    assert!(
+        out.status.success(),
+        "dcr run -- <args> should succeed:\n{combined}"
+    );
+    assert!(
+        combined.contains("ARG:--test_help") && combined.contains("ARG:foo"),
+        "binary should receive args after `--`:\n{combined}"
+    );

    let out = run_dcr_env(&["clean", "--release"], &dir, &envs);
    assert!(out.status.success(), "dcr clean --release should succeed");
-    let target_dir = "target/x86_64-unknown-linux-gnu".to_string();
+    let release_dir = host_profile_dir(&dir, "release");
+    let debug_dir = host_profile_dir(&dir, "debug");
    assert!(
-        !dir.join(&target_dir).join("release").exists(),
-        "target/x86_64-unknown-linux-gnu/release should be removed"
+        !release_dir.exists(),
+        "release profile dir should be removed: {}",
+        release_dir.display()
    );
    assert!(
-        dir.join(&target_dir).join("debug").is_dir(),
-        "target/x86_64-unknown-linux-gnu/debug should remain"
+        debug_dir.is_dir(),
+        "debug profile dir should remain: {}",
+        debug_dir.display()
    );

    let out = run_dcr_env(&["clean"], &dir, &envs);
@@ -116,16 +153,21 @@ fn build_with_target_config() {

    let envs = [("DCR_COMPILER", compiler)];
    let out = run_dcr_env(&["build"], &dir, &envs);
-    assert!(
-        out.status.success(),
-        "dcr build with target = \"linux\" should succeed"
-    );
+    if !out.status.success() {
+        eprintln!("stdout: {}", String::from_utf8_lossy(&out.stdout));
+        eprintln!("stderr: {}", String::from_utf8_lossy(&out.stderr));
+        eprintln!("skipping linux-target path assert: build failed (no suitable toolchain)");
+        return;
+    }

-    let artifact = default_artifact_path(&dir, &project_name);
-    assert!(
-        artifact.is_file(),
-        "artifact should be at default path target/x86_64-unknown-linux-gnu/debug/{}",
-        project_name
+    let out_dir = dir
+        .join("target")
+        .join("x86_64-unknown-linux-gnu")
+        .join("debug");
+    assert_artifact_in(
+        &out_dir,
+        &project_name,
+        "build.target=linux should place artifact under target/x86_64-unknown-linux-gnu/debug",
    );
 }

@@ -157,11 +199,10 @@ fn build_with_out_dir() {
        "dcr build with out_dir should succeed"
    );

-    let artifact = dir.join("_BUILD").join(&project_name);
-    assert!(
-        artifact.is_file(),
-        "artifact should be at _BUILD/{} (custom out_dir)",
-        project_name
+    assert_artifact_in(
+        &dir.join("_BUILD"),
+        &project_name,
+        "artifact should be under custom out_dir _BUILD",
    );

    let default_path = default_artifact_path(&dir, &project_name);
@@ -170,3 +211,148 @@ fn build_with_out_dir() {
        "artifact should NOT be at default path when out_dir is set"
    );
 }
+
+#[test]
+fn flat_bin_nasm_build() {
+    let nasm_ok = std::process::Command::new("nasm")
+        .arg("-v")
+        .output()
+        .map(|o| o.status.success())
+        .unwrap_or(false);
+    if !nasm_ok {
+        eprintln!("nasm not found; skipping flat-bin test");
+        return;
+    }
+
+    let dir = unique_sandbox_dir("flat_bin");
+    let out = run_dcr(&["init"], &dir);
+    assert!(out.status.success(), "dcr init should succeed");
+
+    std::fs::write(
+        dir.join("dcr.toml"),
+        r#"[package]
+name = "flatdemo"
+version = "0.1.0"
+
+[build]
+language = "asm"
+compiler = "nasm"
+kind = "flat-bin"
+extension = "bin"
+roots = ["src"]
+"#,
+    )
+    .expect("write dcr.toml");
+
+    std::fs::create_dir_all(dir.join("src")).expect("src");
+    std::fs::write(
+        dir.join("src/boot.asm"),
+        "bits 16\norg 0x7c00\ncli\nhlt\ntimes 510-($-$$) db 0\ndw 0xaa55\n",
+    )
+    .expect("write boot.asm");
+
+    let out = run_dcr(&["build"], &dir);
+    if !out.status.success() {
+        eprintln!("stdout: {}", String::from_utf8_lossy(&out.stdout));
+        eprintln!("stderr: {}", String::from_utf8_lossy(&out.stderr));
+    }
+    assert!(out.status.success(), "flat-bin nasm build should succeed");
+
+    let boot = host_profile_dir(&dir, "debug").join("boot.bin");
+    assert!(
+        boot.is_file(),
+        "expected boot.bin under host profile dir: {}",
+        boot.display()
+    );
+}
+
+#[test]
+fn package_build_target_used_without_cli_flag() {
+    let Some(compiler) = available_compiler() else {
+        eprintln!("no compiler found; skipping package target test");
+        return;
+    };
+
+    let dir = unique_sandbox_dir("pkg_target");
+    let out = run_dcr(&["init"], &dir);
+    assert!(out.status.success());
+
+    let toml_path = dir.join("dcr.toml");
+    let toml = std::fs::read_to_string(&toml_path).unwrap();
+    let project_name = parse_project_name(&toml);
+    let updated = toml.replace("[build]", "[build]\ntarget = \"x86_64-unknown-linux-gnu\"");
+    std::fs::write(&toml_path, updated).unwrap();
+
+    let envs = [("DCR_COMPILER", compiler)];
+    let out = run_dcr_env(&["build"], &dir, &envs);
+    if !out.status.success() {
+        eprintln!("stdout: {}", String::from_utf8_lossy(&out.stdout));
+        eprintln!("stderr: {}", String::from_utf8_lossy(&out.stderr));
+        eprintln!("skipping package-target path assert: build failed (no suitable toolchain)");
+        return;
+    }
+
+    let out_dir = dir
+        .join("target")
+        .join("x86_64-unknown-linux-gnu")
+        .join("debug");
+    assert_artifact_in(
+        &out_dir,
+        &project_name,
+        "artifact should be under package build.target path",
+    );
+}
+
+#[test]
+fn host_target_section_ldflags_apply_without_cli_target() {
+    let Some(compiler) = available_compiler() else {
+        eprintln!("no compiler found; skipping host target ldflags test");
+        return;
+    };
+
+    let dir = unique_sandbox_dir("host_ldflags");
+    let out = run_dcr(&["init"], &dir);
+    assert!(out.status.success(), "dcr init should succeed");
+
+    let host = if cfg!(target_os = "linux") {
+        let arch = std::env::consts::ARCH;
+        let env = if cfg!(target_env = "musl") {
+            "musl"
+        } else {
+            "gnu"
+        };
+        format!("{arch}-unknown-linux-{env}")
+    } else if cfg!(target_os = "macos") {
+        format!("{}-apple-darwin", std::env::consts::ARCH)
+    } else if cfg!(target_os = "windows") {
+        let env = if cfg!(target_env = "gnu") {
+            "gnu"
+        } else {
+            "msvc"
+        };
+        format!("{}-pc-windows-{env}", std::env::consts::ARCH)
+    } else {
+        eprintln!("unsupported host for host_target_section test; skipping");
+        return;
+    };
+
+    let toml_path = dir.join("dcr.toml");
+    let toml = std::fs::read_to_string(&toml_path).expect("read dcr.toml");
+    let updated = format!(
+        "{toml}\n[build.{host}]\nldflags = [\"-Wl,-rpath,/nonexistent-dcr-host-ldflags\"]\n"
+    );
+    std::fs::write(&toml_path, updated).expect("write dcr.toml");
+
+    let envs = [("DCR_COMPILER", compiler), ("DCR_DEBUG", "1")];
+    let out = run_dcr_env(&["build", "--force"], &dir, &envs);
+    let combined = format!(
+        "{}{}",
+        String::from_utf8_lossy(&out.stdout),
+        String::from_utf8_lossy(&out.stderr)
+    );
+    assert!(
+        combined.contains("-Wl,-rpath,/nonexistent-dcr-host-ldflags")
+            || combined.contains("rpath,/nonexistent-dcr-host-ldflags"),
+        "host target section ldflags must be applied on native build:\n{combined}"
+    );
+}
--- a/tests/cli_deps.rs
+++ b/tests/cli_deps.rs
@@ -117,12 +117,24 @@ fn registry_dependency_is_built_from_cache() {
        "[registry.local]\nurl = \"file://local\"\npriority = 1\n",
    )
    .expect("failed to write registry config");
+    let dep_abs = dep.canonicalize().unwrap_or(dep.clone());
+    let mut dep_path = dep_abs.to_string_lossy().replace('\\', "/");
+    if let Some(rest) = dep_path.strip_prefix("//?/") {
+        dep_path = rest.to_string();
+    }
+    if dep_path.len() >= 3 && dep_path.as_bytes()[0] == b'/' && dep_path.as_bytes()[2] == b':' {
+        dep_path = dep_path[1..].to_string();
+    }
    std::fs::write(
        dcr_home.join("index.json"),
-        format!(
-            "{{\"packages\":[{{\"name\":\"mylib\",\"latest_version\":\"0.1.0\",\"path\":\"{}\"}}]}}",
-            dep.display()
-        ),
+        serde_json::json!({
+            "packages": [{
+                "name": "mylib",
+                "latest_version": "0.1.0",
+                "path": dep_path
+            }]
+        })
+        .to_string(),
    )
    .expect("failed to write registry index");

@@ -151,11 +163,16 @@ fn registry_dependency_is_built_from_cache() {
    .expect("failed to write app source");

    let index_path = dcr_home.join("index.json");
-    let envs = [
+    let home_s = home.to_string_lossy().to_string();
+    let index_s = index_path.to_string_lossy().to_string();
+    let mut envs = vec![
        ("DCR_COMPILER", compiler),
-        ("HOME", home.to_str().unwrap()),
-        ("DCR_INDEX_PATH", index_path.to_str().unwrap()),
+        ("HOME", home_s.as_str()),
+        ("DCR_INDEX_PATH", index_s.as_str()),
    ];
+    if cfg!(windows) {
+        envs.push(("USERPROFILE", home_s.as_str()));
+    }
    let out = run_dcr_env(&["build"], &app, &envs);
    if !out.status.success() {
        eprintln!("stdout: {}", String::from_utf8_lossy(&out.stdout));
--- a/tests/cli_errors.rs
+++ b/tests/cli_errors.rs
@@ -74,6 +74,32 @@ fn available_compiler() -> Option<&'static str> {
    None
 }

+fn host_profile_dir(project_root: &Path, profile: &str) -> PathBuf {
+    let target = project_root.join("target");
+    if cfg!(any(
+        target_os = "linux",
+        target_os = "freebsd",
+        target_os = "openbsd",
+        target_os = "netbsd",
+        target_os = "dragonfly"
+    )) {
+        let arch = std::env::consts::ARCH;
+        let triple = if cfg!(target_os = "linux") {
+            let env = if cfg!(target_env = "musl") {
+                "musl"
+            } else {
+                "gnu"
+            };
+            format!("{arch}-unknown-linux-{env}")
+        } else {
+            format!("{arch}-unknown-{}", std::env::consts::OS)
+        };
+        target.join(triple).join(profile)
+    } else {
+        target.join(profile)
+    }
+}
+
 // --- Tests ---

 #[test]
@@ -92,9 +118,17 @@ fn no_args_shows_help() {
 fn unknown_command_fails() {
    let dir = unique_sandbox_dir("unknown_cmd");
    let out = run_dcr(&["foobar"], &dir);
-    let stdout = String::from_utf8_lossy(&out.stdout);
    assert!(
-        stdout.contains("error") || stdout.contains("Unknown"),
+        !out.status.success(),
+        "unknown command should exit non-zero"
+    );
+    let combined = format!(
+        "{}{}",
+        String::from_utf8_lossy(&out.stdout),
+        String::from_utf8_lossy(&out.stderr)
+    );
+    assert!(
+        combined.contains("error") || combined.contains("Unknown"),
        "unknown command should print error"
    );
 }
@@ -104,9 +138,13 @@ fn build_without_toml_fails() {
    let dir = unique_sandbox_dir("build_no_toml");
    let out = run_dcr(&["build"], &dir);
    assert!(!out.status.success(), "build without dcr.toml should fail");
-    let stdout = String::from_utf8_lossy(&out.stdout);
+    let combined = format!(
+        "{}{}",
+        String::from_utf8_lossy(&out.stdout),
+        String::from_utf8_lossy(&out.stderr)
+    );
    assert!(
-        stdout.contains("dcr.toml") || stdout.contains("not found"),
+        combined.contains("dcr.toml") || combined.contains("not found"),
        "should mention missing dcr.toml"
    );
 }
@@ -132,9 +170,13 @@ fn new_existing_dir_fails() {
    std::fs::create_dir_all(dir.join("hello")).expect("failed to create dir");
    let out = run_dcr(&["new", "hello"], &dir);
    assert!(!out.status.success(), "dcr new on existing dir should fail");
-    let stdout = String::from_utf8_lossy(&out.stdout);
+    let combined = format!(
+        "{}{}",
+        String::from_utf8_lossy(&out.stdout),
+        String::from_utf8_lossy(&out.stderr)
+    );
    assert!(
-        stdout.contains("already exists") || stdout.contains("error"),
+        combined.contains("already exists") || combined.contains("error"),
        "should report dir already exists"
    );
 }
@@ -149,9 +191,13 @@ fn init_nonempty_dir_fails() {
        !out.status.success(),
        "dcr init in non-empty dir should fail"
    );
-    let stdout = String::from_utf8_lossy(&out.stdout);
+    let combined = format!(
+        "{}{}",
+        String::from_utf8_lossy(&out.stdout),
+        String::from_utf8_lossy(&out.stderr)
+    );
    assert!(
-        stdout.contains("not empty") || stdout.contains("error"),
+        combined.contains("not empty") || combined.contains("error"),
        "should report dir not empty"
    );
 }
@@ -186,9 +232,13 @@ fn run_library_project_fails() {
    let envs = [("DCR_COMPILER", compiler)];
    let out = run_dcr_env(&["run"], &dir, &envs);
    assert!(!out.status.success(), "dcr run on staticlib should fail");
-    let stdout = String::from_utf8_lossy(&out.stdout);
+    let combined = format!(
+        "{}{}",
+        String::from_utf8_lossy(&out.stdout),
+        String::from_utf8_lossy(&out.stderr)
+    );
    assert!(
-        stdout.contains("library") || stdout.contains("Cannot run"),
+        combined.contains("library") || combined.contains("Cannot run"),
        "should report cannot run library"
    );
 }
@@ -199,25 +249,24 @@ fn clean_specific_profile() {
    let out = run_dcr(&["init"], &dir);
    assert!(out.status.success(), "init should succeed");

-    // Create target/x86_64-unknown-linux-gnu/debug and release dirs
-    let target_base = "target/x86_64-unknown-linux-gnu";
-    std::fs::create_dir_all(dir.join(target_base).join("debug")).expect("create debug");
-    std::fs::write(dir.join(target_base).join("debug").join("dummy.o"), "x").expect("write");
-    std::fs::create_dir_all(dir.join(target_base).join("release")).expect("create release");
-    std::fs::write(dir.join(target_base).join("release").join("dummy.o"), "x").expect("write");
+    let debug_dir = host_profile_dir(&dir, "debug");
+    let release_dir = host_profile_dir(&dir, "release");
+    std::fs::create_dir_all(&debug_dir).expect("create debug");
+    std::fs::write(debug_dir.join("dummy.o"), "x").expect("write");
+    std::fs::create_dir_all(&release_dir).expect("create release");
+    std::fs::write(release_dir.join("dummy.o"), "x").expect("write");

-    // Clean only release
    let out = run_dcr(&["clean", "--release"], &dir);
    assert!(out.status.success(), "clean --release should succeed");
    assert!(
-        !dir.join(target_base).join("release").exists(),
-        "target/x86_64-unknown-linux-gnu/release should be removed"
+        !release_dir.exists(),
+        "release profile dir should be removed: {}",
+        release_dir.display()
    );
    assert!(
-        dir.join("target/x86_64-unknown-linux-gnu")
-            .join("debug")
-            .is_dir(),
-        "target/x86_64-unknown-linux-gnu/debug should remain"
+        debug_dir.is_dir(),
+        "debug profile dir should remain: {}",
+        debug_dir.display()
    );
 }

@@ -226,9 +275,13 @@ fn new_no_name_fails() {
    let dir = unique_sandbox_dir("new_noname");
    let out = run_dcr(&["new"], &dir);
    assert!(!out.status.success(), "dcr new without name should fail");
-    let stdout = String::from_utf8_lossy(&out.stdout);
+    let combined = format!(
+        "{}{}",
+        String::from_utf8_lossy(&out.stdout),
+        String::from_utf8_lossy(&out.stderr)
+    );
    assert!(
-        stdout.contains("not specified") || stdout.contains("error"),
+        combined.contains("not specified") || combined.contains("error"),
        "should report name not specified"
    );
 }
@@ -251,19 +304,20 @@ fn staticlib_build() {
    let envs = [("DCR_COMPILER", compiler)];
    let out = run_dcr_env(&["build"], &dir, &envs);
    assert!(out.status.success(), "staticlib build should succeed");
-    // Check that a .a file exists
-    let lib_path = dir
-        .join("target")
-        .join("x86_64-unknown-linux-gnu")
-        .join("debug");
+    let lib_path = host_profile_dir(&dir, "debug");
    let has_lib = std::fs::read_dir(&lib_path)
        .map(|entries| {
-            entries
-                .filter_map(|e| e.ok())
-                .any(|e| e.file_name().to_string_lossy().ends_with(".a"))
+            entries.filter_map(|e| e.ok()).any(|e| {
+                let name = e.file_name().to_string_lossy().to_string();
+                name.ends_with(".a") || name.ends_with(".lib")
+            })
        })
        .unwrap_or(false);
-    assert!(has_lib, "staticlib should produce a .a file");
+    assert!(
+        has_lib,
+        "staticlib should produce a .a/.lib in {}",
+        lib_path.display()
+    );
 }

 #[test]
@@ -279,12 +333,11 @@ fn build_release_profile() {
    let envs = [("DCR_COMPILER", compiler)];
    let out = run_dcr_env(&["build", "--release"], &dir, &envs);
    assert!(out.status.success(), "release build should succeed");
+    let release_dir = host_profile_dir(&dir, "release");
    assert!(
-        dir.join("target")
-            .join("x86_64-unknown-linux-gnu")
-            .join("release")
-            .is_dir(),
-        "target/x86_64-unknown-linux-gnu/release should exist"
+        release_dir.is_dir(),
+        "release profile dir should exist: {}",
+        release_dir.display()
    );
 }

--- a/tests/cli_gen.rs
+++ b/tests/cli_gen.rs
@@ -0,0 +1,151 @@
+mod common;
+use common::*;
+use std::fs;
+use std::path::Path;
+
+#[test]
+fn gen_project_info_has_artifact_path() {
+    let dir = unique_sandbox_dir("gen_pi");
+    let out = run_dcr(&["new", "app", "--vcs", "none"], &dir);
+    assert!(out.status.success());
+    let project = dir.join("app");
+
+    let out = run_dcr(&["gen", "project-info", "-q"], &project);
+    assert!(
+        out.status.success(),
+        "project-info failed: {}",
+        String::from_utf8_lossy(&out.stderr)
+    );
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(
+        stdout.contains("\"artifact_path\""),
+        "missing artifact_path: {stdout}"
+    );
+    assert!(stdout.contains("\"target_dir\""), "missing target_dir");
+    assert!(
+        stdout.contains("\"artifact_kind\""),
+        "missing artifact_kind"
+    );
+    assert!(stdout.contains("\"source_roots\""), "missing source_roots");
+
+    let root_canon = fs::canonicalize(&project).unwrap();
+    assert!(
+        stdout.contains(&root_canon.to_string_lossy().to_string()) || stdout.contains("app"),
+        "root should be absolute-ish: {stdout}"
+    );
+
+    assert!(project.join(".dcr").join("build-info.json").is_file());
+    assert!(project.join(".dcr").join("toolchain.json").is_file());
+    assert!(project.join(".clangd").is_file());
+    let clangd = fs::read_to_string(project.join(".clangd")).unwrap();
+    assert!(clangd.contains("CompilationDatabase: .dcr"));
+}
+
+#[test]
+fn gen_compile_commands_in_dcr_dir() {
+    let dir = unique_sandbox_dir("gen_cc");
+    let out = run_dcr(&["new", "app", "--vcs", "none"], &dir);
+    assert!(out.status.success());
+    let project = dir.join("app");
+
+    let out = run_dcr(&["gen", "compile-commands", "-q"], &project);
+    assert!(
+        out.status.success(),
+        "compile-commands failed: {}",
+        String::from_utf8_lossy(&out.stderr)
+    );
+    assert!(
+        !project.join("compile_commands.json").exists(),
+        "compile_commands.json must not be in project root"
+    );
+    let cc = project.join(".dcr").join("compile_commands.json");
+    assert!(cc.is_file(), "expected .dcr/compile_commands.json");
+    let content = fs::read_to_string(&cc).unwrap();
+    assert!(content.contains("\"directory\""), "missing directory field");
+    assert!(content.contains("\"file\""), "missing file field");
+    assert!(content.starts_with('['));
+
+    assert!(project.join(".clangd").is_file());
+    assert!(project.join(".dcr").join("ide").is_dir());
+}
+
+#[test]
+fn gen_clangd_not_overwritten_if_custom() {
+    let dir = unique_sandbox_dir("gen_clangd");
+    let out = run_dcr(&["new", "app", "--vcs", "none"], &dir);
+    assert!(out.status.success());
+    let project = dir.join("app");
+
+    let custom = "CompileFlags:\n  Add: [-Wall]\n";
+    fs::write(project.join(".clangd"), custom).unwrap();
+
+    let out = run_dcr(&["gen", "compile-commands", "-q"], &project);
+    assert!(out.status.success());
+    let after = fs::read_to_string(project.join(".clangd")).unwrap();
+    assert_eq!(after, custom, "custom .clangd must not be overwritten");
+}
+
+#[test]
+fn gen_vscode_launch_uses_resolver() {
+    let dir = unique_sandbox_dir("gen_vscode");
+    let out = run_dcr(&["new", "app", "--vcs", "none"], &dir);
+    assert!(out.status.success());
+    let project = dir.join("app");
+
+    let out = run_dcr(&["gen", "vscode"], &project);
+    assert!(
+        out.status.success(),
+        "gen vscode failed: {}",
+        String::from_utf8_lossy(&out.stderr)
+    );
+    let launch = fs::read_to_string(project.join(".vscode").join("launch.json")).unwrap();
+    assert!(launch.contains("\"program\""), "launch missing program");
+    let normalized = launch.replace("\\\\", "/").replace('\\', "/");
+    let expected_rel = host_profile_dir(&project, "debug")
+        .join(bin_name("app"))
+        .strip_prefix(&project)
+        .unwrap_or_else(|_| Path::new("target"))
+        .to_string_lossy()
+        .replace('\\', "/");
+    assert!(
+        normalized.contains(&expected_rel),
+        "program should use host profile layout ({expected_rel}): {launch}"
+    );
+    let settings = fs::read_to_string(project.join(".vscode").join("settings.json")).unwrap();
+    assert!(
+        settings.contains(".dcr") || settings.contains("compile-commands-dir"),
+        "settings should point at .dcr: {settings}"
+    );
+}
+
+#[test]
+fn build_print_artifact_path() {
+    if available_compiler().is_none() {
+        return;
+    }
+    let dir = unique_sandbox_dir("build_print");
+    let out = run_dcr(&["new", "app", "--vcs", "none"], &dir);
+    assert!(out.status.success());
+    let project = dir.join("app");
+
+    let out = run_dcr(&["build", "--print-artifact-path"], &project);
+    assert!(
+        out.status.success(),
+        "build failed: {}",
+        String::from_utf8_lossy(&out.stderr)
+    );
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    let path_line = stdout
+        .lines()
+        .map(str::trim)
+        .rfind(|l| !l.is_empty())
+        .unwrap_or("");
+    assert!(
+        Path::new(path_line).is_absolute() || path_line.contains("app"),
+        "expected artifact path on stdout, got: {stdout}"
+    );
+    assert!(
+        project.join(".dcr").join("build-info.json").is_file(),
+        "build-info.json should be written after build"
+    );
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Dexoron	b0e426c189	Merge pull request #32 from dexoron/dev feat: add package.dcr-version pin with load-time compatibility warnings	2026-08-08 15:00:02 +08:00
Dexoron	60d7420929	feat: add package.dcr-version pin with load-time compatibility warnings	2026-08-08 14:33:46 +08:00
Dexoron	3bd91e85f9	Merge pull request #31 from dexoron/dev v0.8.4	2026-08-05 21:22:20 +08:00
Dexoron	a20c61cc88	docs: add and clean up AI-generated rustdoc comments (grok-4.5)	2026-08-05 19:21:00 +08:00
Dexoron	bc308d6996	fix: make cross-target tests and vscode launch path robust for macOS + Windows	2026-08-05 02:21:29 +08:00
Dexoron	09e7f5b880	fix(test): align vscode launch path assertion with native host layout	2026-08-05 01:04:43 +08:00
Dexoron	3f925f437f	fix: keep native host artifact paths and cross-platform path assertions	2026-08-05 01:00:26 +08:00
Dexoron	b9cbef43e9	feat: add .dcr/ build facts and canonical artifact paths for IDE integrations	2026-08-05 00:38:00 +08:00
Dexoron	9bf1346d1b	Merge pull request #30 from dexoron/dev v0.8.3	2026-08-03 21:32:18 +08:00
Dexoron	794d571d58	fix: distinguish implicit host builds from explicit targets	2026-08-03 21:26:34 +08:00
Dexoron	d2df85a064	fix: preserve native artifact paths on Windows and macOS	2026-08-03 21:16:11 +08:00
Dexoron	5e8037da97	feat: host-target config resolution and cargo-style run args	2026-08-03 00:40:51 +08:00
Dexoron	f29322a547	Merge pull request #29 from dexoron/dev v0.8.2	2026-07-24 19:15:55 +08:00
Dexoron	1a6a261cac	fix(ci): fix tests	2026-07-23 21:35:59 +08:00
Dexoron	f92cc6ae91	fix(ci): fix tests	2026-07-23 19:59:37 +08:00
Dexoron	5aefbc6498	fix(ci): fix tests	2026-07-23 19:53:48 +08:00
Dexoron	594007f022	fix(ci): fix tests	2026-07-23 19:45:31 +08:00
Dexoron	d10ec84004	fix(ci): fix tests	2026-07-23 19:30:39 +08:00
Dexoron	574ba8b6d0	fix(ci): fix tests	2026-07-23 16:11:39 +08:00
Dexoron	75eace9d73	feat: add dcrup (sh/ps1/cmd) and fix cross-platform unit tests	2026-07-23 14:59:28 +08:00
Dexoron	2446cb7970	feat(docs): remove DPM in install steps	2026-07-23 14:03:08 +08:00
Dexoron	588e4dd13f	feat(build): archive feature, progress UI, and workspace path fixes	2026-07-23 14:00:00 +08:00
Dexoron	689fea7465	Merge pull request #28 from dexoron/dev v0.8.1	2026-07-21 18:12:56 +08:00
Dexoron	a9dd8c1631	feat(build): add flat-bin kind and FAT [archive] packing for OS-dev	2026-07-21 17:45:02 +08:00
Dexoron	1dcc8e614a	Merge pull request #25 from dexoron/dev v0.8.0	2026-07-18 20:05:12 +08:00
Dexoron	a3f8444c20	Replace GitLab pipeline trigger with Cloudflare build	2026-07-05 18:24:47 +08:00
Dexoron	1f3fc62cb6	Add GitHub Actions workflow to trigger site rebuild	2026-07-05 18:16:45 +08:00
Dexoron	f8d8c95912	Rename сrowdin.yml to crowdin.yml (latin)	2026-07-05 17:26:00 +08:00
Dexoron	9e07f70c78	fix crowdin file name	2026-07-05 17:24:14 +08:00
Dexoron	0376eded3f	add Crowdin	2026-07-05 17:21:33 +08:00
Dexoron	803d5891ce	Merge pull request #21 from dexoron/dev v0.7.4	2026-06-19 17:50:59 +08:00
Dexoron	97db82e4f8	Merge pull request #20 from dexoron/dev v0.7.3	2026-06-15 22:36:12 +08:00