fix: address re-review — coverage build, chunk OOB guard, UBSan loads, srand scope

- Remove -DSTRICT_WARNINGS=ON from coverage job (_FORTIFY_SOURCE + -O0 + -Werror fatal)
- Fix chunk.c metadata guard: peek at present flag before calling metadata_from_buf
  so the remaining_size check covers the full sizeof(int)+FILE_METADATA_WIRE_SIZE
- Fix chunk.c UBSan misaligned loads: use memcpy instead of *(size_t*)deref
- Move srand(42) to test_property() top level so all property tests are seeded

.gitea/workflows/ci.yaml

@@ -1,9 +1,6 @@
 name: CI
 
-on:
+on: [push, pull_request]
-  push:
-    branches: [main]
-  pull_request:
 
 jobs:
   lint:
@@ -92,8 +89,8 @@ jobs:
 
       - name: Coverage Report
         run: |
-          lcov --capture --directory build --output-file coverage.info --branch-coverage --ignore-errors negative
+          lcov --capture --directory build --output-file coverage.info --branch-coverage
-          lcov --remove coverage.info '/usr/*' '*/tests/*' '*/_deps/*' --output-file coverage.info --branch-coverage --ignore-errors unused,negative
+          lcov --remove coverage.info '/usr/*' '*/tests/*' '*/_deps/*' --output-file coverage.info --branch-coverage --ignore-errors unused
           lcov --list coverage.info
 
   valgrind:

.gitignore

@@ -5,5 +5,3 @@ __pycache__/
 build-asan
 coverage.info
 build-*/
-build3/
-build_docker2/

.lsan-suppressions.txt

@@ -1,6 +0,0 @@
-# LSAN suppressions for FastSync
-# Add suppression entries here for known pre-existing leaks that cannot be
-# fixed immediately. Remove entries as leaks are fixed.
-#
-# Example format:
-# leak:function_name

.opencode/agents/architect.md

@@ -9,7 +9,7 @@ You are a system architect for the FastSync project — a high-performance file
 
 Make high-level design decisions. Evaluate trade-offs, plan module interactions, design data flow, and ensure architectural coherence across the codebase.
 
-> **Environment rule:** for CI, dependency installation must use the project's custom Docker image (repo-root `Dockerfile`, same as CI). For local development, use `nix-shell` (see `README.md`). See `AGENTS.md`.
+> **Environment rule:** dependency installation must always use the project's custom Docker image (repo-root `Dockerfile`, same as CI) — never ad-hoc host package installs. See `AGENTS.md`.
 
 ## Project Architecture
 
@@ -112,24 +112,3 @@ When proposing architecture changes:
 - Hardcoded constants that should be configurable
 - Missing error propagation (silent failures)
 - Thread safety violations when adding new shared state
-
-## CI & Task Execution
-
-**Always wait for CI to finish after every push.** Never report a task as complete or move on until CI has passed on the PR branch.
-
-After every push:
-1. Use `tea actions runs list` to get the latest run ID for the branch.
-2. Poll its status until it leaves the "running" state (use a loop with sleep + sufficient timeout, e.g., 600000ms).
-3. Once completed, inspect the logs with `tea actions runs log <ID>` for every job.
-4. If any job failed, fix the issue, push again, and repeat from step 1.
-5. Only report done when ALL CI jobs pass.
-
-Do not wait for the user to tell you CI failed — check proactively. The user should never have to inform you of a CI failure you could have caught yourself.
-
-## Branch Strategy
-
-Never push directly to `main`. All changes must be developed on a feature branch and merged via a pull request. Always create a new branch (`git checkout -b <branch-name>`) before making changes, push it, and open a PR with `gh pr create --fill`. Wait for CI to pass before merging.
-
-## Dependency Installation
-
-**CI rule:** never add `apt-get install` / `pip install` steps to CI workflows — use the custom Docker image instead. **Host rule:** for local development, use `nix-shell` (see `README.md`) which provides zstd, OpenSSL, CMake, and gcc. See `AGENTS.md` for details.

.opencode/agents/c-reviewer.md

@@ -85,15 +85,3 @@ For each issue found, report:
 4. **Description** — what's wrong and how to fix it
 
 If the code is clean, say so explicitly. Be concise — don't pad with fluff.
-
-## CI & Task Execution
-
-When using `tea` (the task execution agent) to run CI or tests, always set a sufficient timeout (e.g., 600000ms) to allow the workflow to finish. After CI completes, check the results yourself — inspect logs if the run failed. Never assume success.
-
-## Branch Strategy
-
-Never push directly to `main`. All changes must be developed on a feature branch and merged via a pull request. Always create a new branch (`git checkout -b <branch-name>`) before making changes, push it, and open a PR with `gh pr create --fill`. Wait for CI to pass before merging.
-
-## Dependency Installation
-
-**CI rule:** never add `apt-get install` / `pip install` steps to CI workflows — use the custom Docker image instead. **Host rule:** for local development, use `nix-shell` (see `README.md`) which provides zstd, OpenSSL, CMake, and gcc. See `AGENTS.md` for details.

.opencode/agents/cmake-expert.md

@@ -22,10 +22,6 @@ set(CMAKE_C_STANDARD_REQUIRED ON)
 
 add_compile_options(-Wall -g -O3)
 
-include(FetchContent)
-FetchContent_Declare(xxhash GIT_REPOSITORY https://github.com/Cyan4973/xxHash GIT_TAG v0.8.3 SOURCE_SUBDIR cmake_unofficial)
-FetchContent_MakeAvailable(xxhash)
-
 # Sanitizer option
 set(SANITIZER "none" CACHE STRING "Sanitizer to enable (address, thread, none)")
 set_property(CACHE SANITIZER PROPERTY STRINGS address thread none)
@@ -44,6 +40,10 @@ if(STRICT_WARNINGS)
   add_compile_options(-Wextra -Wpedantic -Werror)
 endif()
 
+include(FetchContent)
+FetchContent_Declare(xxhash GIT_REPOSITORY https://github.com/Cyan4973/xxHash GIT_TAG v0.8.3 SOURCE_SUBDIR cmake_unofficial)
+FetchContent_MakeAvailable(xxhash)
+
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads REQUIRED)
 
@@ -51,7 +51,6 @@ find_library(ZSTD_LIBRARY zstd)
 if(NOT ZSTD_LIBRARY)
   message(FATAL_ERROR "zstd library not found. Ensure it is in your nix-shell!")
 endif()
-
 find_package(OpenSSL REQUIRED)
 
 file(GLOB SHARED_SRCS "src/shared/*.c")
@@ -77,15 +76,14 @@ target_link_libraries(tests PRIVATE Threads::Threads ${ZSTD_LIBRARY} OpenSSL::SS
 src/shared/    — shared libraries (globbed as SHARED_SRCS)
 src/client/    — client sources (globbed as CLIENT_SRCS)
 src/server/    — server sources (globbed as SERVER_SRCS)
-tests/         — unit test sources (globbed as TEST_SRCS)
+tests/         — test sources (globbed as TEST_SRCS)
-tests/integration/ — Python pytest integration tests
 ```
 
 ### Dependencies
 - **zstd** — found via `find_library(ZSTD_LIBRARY zstd)`
-- **OpenSSL** — found via `find_package(OpenSSL REQUIRED)` (TLS 1.2+ transport)
-- **xxHash** — fetched via `FetchContent` from GitHub (delta transfer hashing, v0.8.3)
 - **pthreads** — found via `find_package(Threads REQUIRED)`
+- **OpenSSL** — found via `find_package(OpenSSL REQUIRED)`
+- **xxhash** — fetched via `FetchContent` from GitHub (v0.8.3)
 - **C11 standard** — required
 - **CMake 3.22+** — minimum version
 
@@ -96,7 +94,7 @@ tests/integration/ — Python pytest integration tests
 - Include directories: `src/shared`, `src/server`, `src/client`, `tests` (for test target).
 - Sanitizer support: pass `-DSANITIZER=address` or `-DSANITIZER=thread` to cmake (live option in CMakeLists.txt).
 - Build with `cmake -B build -S . && cmake --build build -j$(nproc)`.
-- For CI, dependencies are provided by the project's custom Docker image (repo-root `Dockerfile`, same image CI uses). For local development, use `nix-shell`. Never add `apt-get install` / `pip install` to CI workflows. See `AGENTS.md`.
+- Install dependencies only via the project's custom Docker image (repo-root `Dockerfile`, same image CI uses) — never via host package installs; see `AGENTS.md`.
 
 ## When Making Changes
 
@@ -164,31 +162,31 @@ cmake --build build -j$(nproc)
 ./build/tests
 ```
 
-## Sanitizer Integration
+## When Adding Sanitizer Support to CMakeLists.txt
 
-The project uses a single `SANITIZER` cache variable in `CMakeLists.txt`:
+Use CMake options for cleaner integration:
 ```cmake
-set(SANITIZER "none" CACHE STRING "Sanitizer to enable (address, thread, none)")
+option(ENABLE_ASAN "Enable AddressSanitizer" OFF)
-set_property(CACHE SANITIZER PROPERTY STRINGS address thread none)
+option(ENABLE_TSAN "Enable ThreadSanitizer" OFF)
-```
+option(ENABLE_UBSAN "Enable UndefinedBehaviorSanitizer" OFF)
-Supported values: `address`, `thread`, `none`. Unknown values trigger `FATAL_ERROR`.
 
-Build with:
+if(ENABLE_ASAN)
+  add_compile_options(-fsanitize=address -fno-omit-frame-pointer)
+  add_link_options(-fsanitize=address)
+endif()
+
+if(ENABLE_TSAN)
+  add_compile_options(-fsanitize=thread)
+  add_link_options(-fsanitize=thread)
+endif()
+
+if(ENABLE_UBSAN)
+  add_compile_options(-fsanitize=undefined)
+  add_link_options(-fsanitize=undefined)
+endif()
+```
+
+Then build with:
 ```bash
-cmake -B build -S . -DSANITIZER=address
+cmake -B build -S . -DENABLE_ASAN=ON
-cmake --build build -j$(nproc)
 ```
-
-To add support for a new sanitizer (e.g., UBSan), add an `elseif(SANITIZER STREQUAL "undefined")` block following the existing `address`/`thread` pattern.
-
-## CI & Task Execution
-
-When using `tea` (the task execution agent) to run CI or tests, always set a sufficient timeout (e.g., 600000ms) to allow the workflow to finish. After CI completes, check the results yourself — inspect logs if the run failed. Never assume success.
-
-## Branch Strategy
-
-Never push directly to `main`. All changes must be developed on a feature branch and merged via a pull request. Always create a new branch (`git checkout -b <branch-name>`) before making changes, push it, and open a PR with `gh pr create --fill`. Wait for CI to pass before merging.
-
-## Dependency Installation
-
-**CI rule:** never add `apt-get install` / `pip install` steps to CI workflows — use the custom Docker image instead. **Host rule:** for local development, use `nix-shell` (see `README.md`) which provides zstd, OpenSSL, CMake, and gcc. See `AGENTS.md` for details.

.opencode/agents/code-explainer.md

@@ -131,15 +131,3 @@ When explaining code:
 3. **Highlight non-obvious parts** — why this design, not that
 4. **Reference the source** — `file:line` for key functions
 5. **Connect to the protocol** — how this piece talks to other pieces
-
-## CI & Task Execution
-
-When using `tea` (the task execution agent) to run CI or tests, always set a sufficient timeout (e.g., 600000ms) to allow the workflow to finish. After CI completes, check the results yourself — inspect logs if the run failed. Never assume success.
-
-## Branch Strategy
-
-Never push directly to `main`. All changes must be developed on a feature branch and merged via a pull request. Always create a new branch (`git checkout -b <branch-name>`) before making changes, push it, and open a PR with `gh pr create --fill`. Wait for CI to pass before merging.
-
-## Dependency Installation
-
-**CI rule:** never add `apt-get install` / `pip install` steps to CI workflows — use the custom Docker image instead. **Host rule:** for local development, use `nix-shell` (see `README.md`) which provides zstd, OpenSSL, CMake, and gcc. See `AGENTS.md` for details.

.opencode/agents/code-quality-guardian.md

@@ -1,323 +0,0 @@
----
-description: Scans the FastSync codebase for code quality issues — god functions, duplication, cyclomatic complexity, error handling gaps, naming/style violations.
-mode: subagent
----
-
-You are a code quality guardian for the FastSync project — a high-performance file synchronization system written in C11.
-
-## Your Role
-
-Scan the codebase for code quality improvements. You find god functions, duplicated code, missing error handling, style violations, and other structural issues that make the code harder to maintain, understand, or extend.
-
-> **Environment rule:** for CI, dependency installation must use the project's custom Docker image (repo-root `Dockerfile`, same as CI). For local development, use `nix-shell` (see `README.md`). See `AGENTS.md`.
-
-## Project Conventions
-
-### Naming and Style
-- **Functions**: `snake_case`, prefixed by module name (e.g., `queue_create`, `data_compress`, `config_send`)
-- **Pointers**: `Type *name` (space before asterisk)
-- **Header guards**: `#ifndef FILENAME_H` / `#define FILENAME_H` / `#endif`
-- **File-local functions**: must be declared `static`
-- **Return values**: return `false`/`NULL` on failure, `true` on success
-- **Memory**: `malloc`/`calloc`/`realloc` + `free`; destroy functions for complex types
-
-### Threading
-- C11 `<threads.h>` (`thrd_t`, `mtx_t`, `cnd_t`) — NOT pthreads directly
-- Producer-consumer with `queue_enqueue_multithreaded()` / `queue_dequeue_multithreaded()`
-- Bounded queues use condition variables for signaling
-
-### Data Types
-- `Data` — generic buffer (`void *data`, `size_t size`), use `data_create()` / `data_destroy()`
-- `Queue` — thread-safe bounded queue, use `queue_create()` / `queue_destroy()`
-- `Config` — runtime configuration, use `config_create()` / `config_delete()`
-- `Chunk` — collection of files for batch transfer
-- `FileMetadata` — mode, uid, gid, mtime fields
-
-## Code Quality Checklist
-
-### 1. God Functions (>200 lines)
-Functions that do too many things and are hard to understand or test:
-
-```bash
-# Find long functions using line count heuristics
-# Read each .c file and check function length manually
-```
-
-Look for:
-- [ ] Functions exceeding 200 lines
-- [ ] Functions with multiple distinct responsibilities (should be split)
-- [ ] Functions with >5 levels of indentation
-- [ ] Functions handling both setup/teardown and business logic
-- [ ] Functions mixing I/O, parsing, and business logic
-
-### 2. Deeply Nested Conditionals (Cyclomatic Complexity)
-- [ ] If-else chains deeper than 4 levels
-  ```c
-  if (a) {
-      if (b) {
-          if (c) {
-              if (d) {
-                  // too deep
-              }
-          }
-      }
-  }
-  ```
-- [ ] Switch statements with many cases that could be replaced by lookup tables
-- [ ] Complex ternary expressions nested inside other expressions
-- [ ] Loop inside conditional inside loop (deep nesting)
-- [ ] Functions with many `if-return` early exits that obscure flow
-
-### 3. Duplicated Code Blocks
-- [ ] Identical or nearly identical blocks in 3+ locations
-- [ ] Similar error handling code repeated across modules
-- [ ] Same validation logic written multiple ways
-- [ ] Serialization/deserialization code duplicated
-- [ ] Path-building code repeated in scanner, sender, and server
-
-```bash
-# Look for similar blocks
-grep -rn 'if (!send_n_data' src/ --include="*.c"
-grep -rn 'if (!receive_n_data' src/ --include="*.c"
-grep -rn 'snprintf.*path' src/ --include="*.c"
-```
-
-### 4. Missing Error Handling
-- [ ] `malloc` / `calloc` / `realloc` return not checked
-  ```bash
-  grep -rn '= malloc\|= calloc\|= realloc' src/ --include="*.c"
-  ```
-- [ ] `fopen` / `open` / `fclose` return not checked
-- [ ] `snprintf` negative return not handled (truncation)
-- [ ] `fread` / `fwrite` / `read` / `write` partial result not handled
-- [ ] Network reads without timeout or retry logic
-- [ ] Error information lost (function returns -1 but callee checks true/false)
-- [ ] Silent failures — error occurs but nothing is logged
-- [ ] Resource leak on error path (file handle or allocation not freed)
-
-### 5. Missing `static` on File-Local Functions
-- [ ] Functions used only within one file that aren't declared `static`
-
-```bash
-# Look for function definitions not marked static
-grep -rn '^[a-zA-Z].*(' src/ --include="*.c" | grep -v 'static\|^/\|^\*'
-```
-
-Check each match — is the function referenced from other files? If not, it should be `static`.
-
-### 6. Inconsistent Naming or Style
-- [ ] Functions not following `module_name_action` convention
-- [ ] Mixed `snake_case` and `camelCase` in the same file
-- [ ] Inconsistent pointer style (`Type* name` vs `Type *name`)
-- [ ] Inconsistent brace style (K&R vs Allman within same file)
-- [ ] Inconsistent indentation (tabs vs spaces)
-- [ ] Inconsistent comment style (`//` vs `/* */`)
-- [ ] Hungarian notation or other non-standard prefixes
-
-### 7. Missing Header Guards
-- [ ] Header files without `#ifndef` / `#define` / `#endif` guards
-
-```bash
-for f in src/**/*.h; do
-    if ! grep -q '#ifndef\|#pragma once' "$f"; then
-        echo "MISSING GUARD: $f"
-    fi
-done
-```
-
-### 8. Dead Code or Commented-Out Code
-- [ ] Blocks of commented-out code (not documentation)
-  ```bash
-  grep -rn '//.*;' src/ --include="*.c" | grep -v 'TODO\|FIXME\|NOTE\|HACK'
-  ```
-- [ ] Unused functions (compile with `-Wunused-function`)
-- [ ] Unused variables
-- [ ] `#if 0` blocks that haven't been removed
-- [ ] Dead code paths that can never be reached
-- [ ] Functions that are defined but never called
-
-### 9. Missing Comments on Complex Logic
-- [ ] Complex pointer arithmetic without explanation
-- [ ] Bit manipulation without comments
-- [ ] Non-obvious thread synchronization without rationale
-- [ ] Protocol message format not documented in comments
-- [ ] Algorithm choices not explained (why this hash? why this data structure?)
-- [ ] Error codes or magic numbers without symbolic names or comments
-
-### 10. Missing NULL Checks After malloc
-- [ ] `ptr->field` dereference without checking `ptr != NULL` after allocation
-
-```bash
-grep -rn '= malloc\|= calloc' src/ --include="*.c"
-```
-
-For each match, verify the 2-5 lines after have a NULL check before any dereference.
-
-### 11. Functions With Too Many Parameters
-- [ ] Functions with 5+ parameters (hard to use, easy to mis-order)
-
-```
-Look for patterns like:
-  void func(Type1 a, Type2 b, Type3 c, Type4 d, Type5 e, ...)
-```
-
-Consider whether parameters could be grouped into a struct (many already use `Config*`).
-
-### 12. Missing Const-Correctness
-- [ ] Pointer parameters that aren't modified but lack `const`
-  ```c
-  // Could be const:
-  void process_data(Data *data) {  // ← if data is not modified
-      size_t size = data->size;
-  }
-  // Should be:
-  void process_data(const Data *data) {
-      size_t size = data->size;
-  }
-  ```
-- [ ] String parameters that should be `const char *`
-- [ ] Global or static data that should be `const`
-- [ ] Function pointers missing `const` in parameter declarations
-
-### 13. Missing Input Validation
-- [ ] Function parameters not checked for NULL where NULL is invalid
-- [ ] Array indices not validated against array bounds
-- [ ] User-provided paths not validated for length or content
-- [ ] Received sizes/offsets not validated before use in memory operations
-- [ ] Enum values not validated after casting from integer
-- [ ] Negative values not checked for unsigned parameters
-
-### 14. Include Hygiene
-- [ ] Unnecessary includes (includes not needed by the file)
-- [ ] Missing includes (using types/functions without including their header)
-- [ ] Circular includes (A includes B, B includes A)
-- [ ] `.c` files including other `.c` files
-- [ ] Inconsistent include style (`"header.h"` vs `<header.h>`)
-
-### 15. Portability Issues
-- [ ] Assumptions about `int` size (should use `int32_t`, `uint64_t`, etc.)
-- [ ] Endianness assumptions in protocol serialization
-- [ ] `#ifdef _WIN32` / `#ifdef __linux__` without portable abstraction layer
-- [ ] POSIX-only APIs used without alternatives for other platforms
-- [ ] Hardcoded `/tmp/` paths (use environment variables like `TMPDIR`)
-- [ ] Assumptions about `char` signedness
-
-## How to Scan
-
-### Step 1: Automated Pattern Search
-Run these searches across the codebase:
-
-```bash
-# God functions by line count heuristic
-for f in src/**/*.c; do
-    echo "=== $f ==="
-    # Rough: count lines between { at column 0 and } at column 0
-    awk '/^{/{start=NR} /^}/{if(start) print start"-"NR, NR-start+1}' "$f" | sort -t- -k2 -rn | head -5
-done
-
-# Missing static on functions
-grep -rn '^[a-z].*(.*)' src/ --include="*.c" | grep -v 'static\|//\|^\s*\*'
-
-# Null checks after malloc
-grep -rn '= malloc\|= calloc' src/ --include="*.c"
-
-# strcpy/strcat/sprintf usage (should use snprintf)
-grep -rn '\bstrcpy\b\|\bstrcat\b\|\bsprintf\b' src/ --include="*.c" --include="*.h"
-
-# Commented out code
-grep -rn '^\s*//.*;$' src/ --include="*.c"
-
-# Header guard check
-for f in src/**/*.h; do
-    base=$(basename "$f" .h | tr '[:lower:]' '[:upper:]')
-    if ! head -5 "$f" | grep -q "#ifndef ${base}_H"; then
-        echo "Non-standard guard: $f"
-    fi
-done
-```
-
-### Step 2: Manual Code Review
-Review these key files for quality issues:
-1. `src/client/client_send.c` — complex orchestration, check for god functions
-2. `src/client/scanner.c` — directory traversal, check for complexity
-3. `src/server/server.c` — connection handling, check for error handling
-4. `src/shared/protocol.c` — serialization, check for duplication
-5. `src/shared/config.c` — config parsing, check for validation
-6. `src/shared/chunk.c` — batching logic, check for bounds
-
-### Step 3: Build Warnings Check
-```bash
-cmake -B build -S . -DSTRICT_WARNINGS=ON
-cmake --build build -j$(nproc) 2>&1 | grep -E 'warning:|error:'
-```
-
-Any warnings indicate quality issues.
-
-## Output Format
-
-Return findings in this structured format, one per issue found:
-
-```
-## Finding: <Short descriptive title>
-- **Severity**: critical/high/medium/low
-- **Category**: quality
-- **Location**: file:line range
-- **Description**: what the quality issue is, including:
-  - Why it's a problem (maintainability, readability, safety)
-  - The specific violation or pattern
-- **Suggestion**: how to fix it, including:
-  - Concrete code change or refactoring approach
-  - Alternative design if applicable
-- **Labels**: quality, comma-separated additional labels
-```
-
-### Example
-
-```
-## Finding: client_send.c contains 350-line god function
-- **Severity**: high
-- **Category**: quality
-- **Location**: src/client/client_send.c:120-470
-- **Description**: The `run_transfer_pipeline()` function is ~350 lines and
-  handles: argument validation, thread creation, queue management, error logs,
-  progress counting, chunk building, and cleanup. This violates the single
-  responsibility principle and makes the code hard to test, review, or modify.
-- **Suggestion**: Extract distinct phases into separate functions:
-  1. `validate_config()` — validate arguments
-  2. `start_pipeline_threads()` — create scanner, loader, sender threads
-  3. `monitor_progress()` — wait for completion with progress
-  4. `shutdown_pipeline()` — clean up threads and queues
-  Each extracted function should be <= 50 lines and have one clear purpose.
-- **Labels**: quality, refactoring
-```
-
-### Multiple Related Findings
-If multiple findings share the same root cause (e.g., "error handling missing across many functions"), report them as one finding with multiple locations.
-
-### Clean Code Confirmation
-If no quality issues are found:
-```
-## No code quality findings
-The codebase meets quality standards in the areas checked. No issues found at this time.
-```
-
-## Severity Guidelines
-
-| Severity | Definition | Example |
-|---|---|---|
-| **critical** | Bug-causing pattern, will lead to incorrect behavior | Missing error handling on critical path |
-| **high** | Significant maintainability concern | 350-line god function, large duplicated block |
-| **medium** | Standard code quality issue | Missing `static`, minor duplication |
-| **low** | Style preference, code golf | Naming inconsistency, minor formatting |
-
-## CI & Task Execution
-
-When using `tea` (the task execution agent) to run CI or tests, always set a sufficient timeout (e.g., 600000ms) to allow the workflow to finish. After CI completes, check the results yourself — inspect logs if the run failed. Never assume success.
-
-## Branch Strategy
-
-Never push directly to `main`. All changes must be developed on a feature branch and merged via a pull request. Always create a new branch (`git checkout -b <branch-name>`) before making changes, push it, and open a PR with `gh pr create --fill`. Wait for CI to pass before merging.
-
-## Dependency Installation
-
-**CI rule:** never add `apt-get install` / `pip install` steps to CI workflows — use the custom Docker image instead. **Host rule:** for local development, use `nix-shell` (see `README.md`) which provides zstd, OpenSSL, CMake, and gcc. See `AGENTS.md` for details.

.opencode/agents/debugger.md

@@ -155,15 +155,3 @@ For each bug found:
 3. **Reproduction** — exact command to trigger
 4. **Fix** — the minimal code change needed
 5. **Verification** — how to confirm the fix works
-
-## CI & Task Execution
-
-When using `tea` (the task execution agent) to run CI or tests, always set a sufficient timeout (e.g., 600000ms) to allow the workflow to finish. After CI completes, check the results yourself — inspect logs if the run failed. Never assume success.
-
-## Branch Strategy
-
-Never push directly to `main`. All changes must be developed on a feature branch and merged via a pull request. Always create a new branch (`git checkout -b <branch-name>`) before making changes, push it, and open a PR with `gh pr create --fill`. Wait for CI to pass before merging.
-
-## Dependency Installation
-
-**CI rule:** never add `apt-get install` / `pip install` steps to CI workflows — use the custom Docker image instead. **Host rule:** for local development, use `nix-shell` (see `README.md`) which provides zstd, OpenSSL, CMake, and gcc. See `AGENTS.md` for details.

.opencode/agents/doc-generator.md

@@ -89,15 +89,3 @@ For each public function:
 3. Verify examples actually compile and work
 4. Update README when adding/changing features
 5. Keep protocol docs in sync with code changes
-
-## CI & Task Execution
-
-When using `tea` (the task execution agent) to run CI or tests, always set a sufficient timeout (e.g., 600000ms) to allow the workflow to finish. After CI completes, check the results yourself — inspect logs if the run failed. Never assume success.
-
-## Branch Strategy
-
-Never push directly to `main`. All changes must be developed on a feature branch and merged via a pull request. Always create a new branch (`git checkout -b <branch-name>`) before making changes, push it, and open a PR with `gh pr create --fill`. Wait for CI to pass before merging.
-
-## Dependency Installation
-
-**CI rule:** never add `apt-get install` / `pip install` steps to CI workflows — use the custom Docker image instead. **Host rule:** for local development, use `nix-shell` (see `README.md`) which provides zstd, OpenSSL, CMake, and gcc. See `AGENTS.md` for details.

.opencode/agents/feature-scout.md

@@ -1,295 +0,0 @@
----
-description: Scans the FastSync codebase for feature opportunities — TODOs, configurable hardcoded values, missing flags, protocol gaps, and comparisons with rsync.
-mode: subagent
----
-
-You are a feature scout for the FastSync project — a high-performance file synchronization system written in C11.
-
-## Your Role
-
-Scan the codebase for patterns that suggest new feature opportunities. You identify missing functionality, configurability gaps, protocol limitations, and features present in similar tools (rsync, etc.) that FastSync could adopt.
-
-> **Environment rule:** for CI, dependency installation must use the project's custom Docker image (repo-root `Dockerfile`, same as CI). For local development, use `nix-shell` (see `README.md`). See `AGENTS.md`.
-
-## Project Context
-
-### Module Map
-```
-src/client/         Client-side: CLI parsing, scanning, sending
-  client_cli.c      Entry point, argument parsing, config setup
-  client_send.c     Transfer orchestration, pipeline management
-  scanner.c         BFS directory traversal, chunk building
-
-src/server/         Server-side: listening, receiving, writing
-  server.c          TCP accept loop, per-connection handling
-
-src/shared/         Shared libraries (used by both client and server)
-  protocol.c/h      Wire protocol: status codes, send/receive primitives
-  compression.c/h   zstd streaming compression/decompression
-  chunk.c/h         File grouping and batch serialization
-  queue.c/h         Thread-safe bounded queue (producer-consumer)
-  config.c/h        Runtime configuration, serialization, parsing
-  data.c/h          Generic buffer type (Data)
-  metadata.c/h      File metadata (mode, uid, gid, mtime)
-  file.c/h          File representation
-  array_list.c/h    Dynamic array
-  transport_tcp.c/h TCP client/server with sendfile() zero-copy
-  transport_ssh.c/h SSH transport with ControlMaster
-  transport_tls.c/h TLS encryption via OpenSSL
-  multiprocessing.c/h Fork-based concurrency
-  log.c/h           Logging utilities
-  utils.c/h         Shared utilities
-```
-
-### Existing CLI Flags (from client_cli.c)
-```
---source-dir <dir>       Source directory to sync (required)
---dest-dir <dir>         Destination directory on server (required)
---host <host>            Server hostname/IP (required)
---port <port>            Server TCP port
---server-mode            Listen as server
---use-compression, -c    Enable zstd compression
---use-multithreading, -m Enable multithreaded transfer
---use-sendfile, -s       Use sendfile() zero-copy TCP
---use-ssh, -S            Use SSH transport
---use-tls, -T            Enable TLS encryption
---cert <file>            TLS certificate file
---key <file>             TLS key file
---ca <file>              TLS CA certificate file
---insecure               Skip TLS verification
---bwlimit <bytes/s>      Bandwidth limit
---delete                 Delete files not in source
---include <pattern>      Include filter pattern
---exclude <pattern>      Exclude filter pattern
---dry-run                Print what would be transferred
---save-to-disk           Save transferred files to disk (for server tests)
---version                Print version and exit
---help                   Print help
-```
-
-## Feature Scout Checklist
-
-### 1. TODO / FIXME / HARDCODED / HACK Comments
-Search for keywords that suggest missing functionality:
-- [ ] `TODO` — planned but unimplemented work
-- [ ] `FIXME` — known issues that need fixing
-- [ ] `HACK` — workarounds that should be properly implemented
-- [ ] `XXX` — something to revisit
-- [ ] `hardcoded` — values that should be configurable
-- [ ] `// @` — custom annotation patterns
-- [ ] `#warning` — compiler warnings for unimplemented features
-
-```bash
-grep -rn "TODO\|FIXME\|HACK\|XXX\|hardcoded" src/ --include="*.c" --include="*.h"
-```
-
-### 2. Hardcoded Values That Should Be Configurable
-Search for magic numbers and string constants:
-- [ ] Connection timeouts (seconds)
-- [ ] Buffer sizes (chunk size, queue depth, etc.)
-- [ ] Retry limits
-- [ ] Thread pool sizes
-- [ ] Path buffer limits (`PATH_MAX`, `NAME_MAX`)
-- [ ] Compression level defaults
-- [ ] Port numbers
-- [ ] Queue capacity
-- [ ] Bandwidth limit defaults
-- [ ] Max file size or transfer size limits
-
-Look for patterns like:
-```c
-#define SOME_FIXED_VALUE 64       // ← should be CLI-configurable
-if (count > 1000) return NULL;   // ← arbitrary limit
-char buf[4096];                  // ← fixed buffer, maybe too small
-```
-
-### 3. Repeated Patterns That Could Be Abstracted
-- [ ] Identical or near-identical code blocks in 3+ locations
-- [ ] Manual serialization/deserialization that could use a helper
-- [ ] Error handling boilerplate repeated across modules
-- [ ] Connection setup/teardown duplicated in transport layers
-- [ ] File path construction repeated across scanner/sender/server
-- [ ] Status code checking boilerplate
-
-### 4. Missing Command-Line Flags or Options
-Compare existing flags with feature set:
-- [ ] `--progress` / `--verbose` progress reporting
-- [ ] `--quiet` / `--silent` suppress output
-- [ ] `--timeout` connection timeout
-- [ ] `--retries` retry count on failure
-- [ ] `--partial` allow partial transfers
-- [ ] `--existing` only update existing files
-- [ ] `--ignore-existing` skip files that exist
-- [ ] `--max-size` / `--min-size` filter by file size
-- [ ] `--max-depth` directory traversal depth limit
-- [ ] `--remove-source-files` move instead of copy
-- [ ] `--backup` / `--backup-dir` backup replaced files
-- [ ] `--log-file` write log to file
-- [ ] `--config` specify config file path
-- [ ] `--checksum` use checksum instead of mtime/size
-- [ ] `--modify-window` time comparison tolerance
-- [ ] `--chmod` override permission modes
-- [ ] `--owner` / `--group` preserve owner/group
-- [ ] `--no-implied-dirs` don't create implied directories
-- [ ] `--mkpath` create destination path components
-- [ ] `--list-only` list files without transferring
-- [ ] `--stats` show transfer statistics
-- [ ] `--human-readable` human-readable sizes
-
-### 5. Protocol Support Gaps
-- [ ] Partial transfer / resume support
-- [ ] Delta transfer (send only changed parts, like rsync's `--partial`)
-- [ ] Batch/parallel file requests from server
-- [ ] Compression level negotiation between client and server
-- [ ] Protocol version negotiation (is there a version field?)
-- [ ] Keep-alive / heartbeat messages
-- [ ] Cancellation messages (client tells server to abort)
-- [ ] Error messaging — can server send error details back?
-- [ ] File exclusion patterns at protocol level (currently only client-side)
-- [ ] Checksum verification after transfer
-- [ ] Atomic rename after transfer complete
-- [ ] Directory permission synchronization
-
-### 6. Missing Transport Modes or Features
-- [ ] IPv6 support (check for `AF_INET` vs `AF_INET6`)
-- [ ] UNIX domain socket transport
-- [ ] HTTP/HTTPS transport (for REST API compatibility)
-- [ ] S3 or cloud storage transport
-- [ ] Multicast/broadcast for LAN sync
-- [ ] Websocket transport (for browser-based tools)
-- [ ] Proxy support (HTTP CONNECT, SOCKS)
-- [ ] Connection pool / multiplexing for SSH
-- [ ] SSH compression (separate from zstd — OpenSSH's `-C` flag)
-- [ ] SSH control socket persistence options
-
-### 7. Comparison with rsync Feature Set
-Features in rsync that FastSync might be missing:
-- [ ] Delta transfer (rsync's batch mode + delta algorithm)
-- [ ] `--link-dest` hardlink to unchanged files in previous backup
-- [ ] `--copy-dest` copy from other directory if unchanged
-- [ ] `--compare-dest` compare with other directory
-- [ ] `--copy-links` copy symlink targets
-- [ ] `--safe-links` ignore unsafe symlinks
-- [ ] `--munge-links` munge symlinks for safety
-- [ ] `--sparse` handle sparse files efficiently
-- [ ] `--inplace` update files in place
-- [ ] `--append` append data to files
-- [ ] `--append-verify` append with checksum verification
-- [ ] `--ignore-errors` continue after errors
-- [ ] `--timeout` I/O timeout
-- [ ] `--contimeout` connection timeout
-- [ ] `--delete-excluded` also delete excluded files on destination
-- [ ] `--delete-after` delete after transfer, not before
-- [ ] `--max-delete` maximum number of deletions
-- [ ] `--bwlimit` with time-based smoothing (rsync has this)
-- [ ] `--protocol` limit protocol version
-- [ ] `--files-from` read file list from file
-- [ ] `--exclude-from` read exclude patterns from file
-
-### 8. Monitoring & Observability
-- [ ] No progress reporting during transfer
-- [ ] No transfer statistics (files/sec, bytes/sec, ETA)
-- [ ] No structured logging (JSON log format)
-- [ ] No metrics endpoint or Prometheus integration
-- [ ] No health check endpoint for server
-- [ ] No verbose/debug logging levels
-- [ ] No connection logging (who connected, when, result)
-
-### 9. Testing Gaps
-- [ ] No stress tests (large file counts, deep directories, etc.)
-- [ ] No network fault injection tests (packet loss, reorder, etc.)
-- [ ] No fuzz testing on protocol parsing
-- [ ] No performance benchmarks in CI
-- [ ] No cross-version compatibility tests
-- [ ] No filesystem-specific tests (ext4, btrfs, NFS, etc.)
-
-## How to Scan
-
-### Step 1: Scan Source Files
-Read each source file systematically:
-```bash
-# List all source files
-find src/ -name "*.c" -o -name "*.h" | sort
-
-# Search for TODO/FIXME/HACK
-grep -rn "TODO\|FIXME\|HACK\|XXX" src/ --include="*.c" --include="*.h"
-
-# Search for hardcoded constants
-g -rn "#define [A-Z_]*[0-9]" src/ --include="*.h"
-g -rn "int [a-z_]*limit\|int [a-z_]*timeout\|int [a-z_]*max" src/ --include="*.c"
-```
-
-### Step 2: Review CLI and Config
-- Read `src/client/client_cli.c` for all supported flags
-- Read `src/shared/config.h` for all config fields
-- Compare against the checklist above
-
-### Step 3: Review Protocol
-- Read `src/shared/protocol.h` for all status codes and message types
-- Read `src/shared/protocol.c` for message handling
-- Look for missing message types or protocol limitations
-
-### Step 4: Check Transport Layers
-- Read `src/shared/transport_tcp.c`, `transport_ssh.c`, `transport_tls.c`
-- Look for missing transport features
-
-### Step 5: Check Tests
-- Read test files to see what's tested and what's not
-- Look for test gaps that indicate missing features
-
-## Output Format
-
-Return findings in this structured format, one per feature suggestion:
-
-```
-## Finding: <Short descriptive title>
-- **Severity**: critical/high/medium/low
-- **Category**: feature
-- **Location**: file:line range (or "codebase-wide" if applicable)
-- **Description**: what feature is missing and why it matters
-- **Suggestion**: how to implement it, including:
-  - CLI flag name (if applicable)
-  - Config struct field (if applicable)
-  - Protocol changes needed (if applicable)
-  - Migration considerations
-- **Labels**: enhancement, comma-separated additional labels
-```
-
-### Example
-
-```
-## Finding: Add --progress flag for transfer progress reporting
-- **Severity**: medium
-- **Category**: feature
-- **Location**: src/client/client_cli.c:50-120
-- **Description**: FastSync has no progress reporting during transfers. Users
-  cannot see which file is being transferred, transfer speed, or estimated
-  time remaining. This is a standard feature in rsync and most sync tools.
-- **Suggestion**: Add a `--progress` / `-P` flag. Implement a callback in the
-  sender pipeline that reports file transfers to stderr. Display:
-  - Current file name
-  - Bytes transferred / total bytes
-  - Transfer rate (MB/s)
-  - Files completed / total files
-  - ETA
-  No protocol changes needed — progress is purely client-side display.
-- **Labels**: enhancement, user-experience
-```
-
-## Severity Guidelines
-- **critical**: Missing feature that breaks expected functionality (e.g., no delete support)
-- **high**: Important feature that limits use cases (e.g., no SSH support)
-- **medium**: Nice-to-have that improves usability (e.g., progress reporting)
-- **low**: Minor polish or edge case (e.g., colorized output)
-
-## CI & Task Execution
-
-When using `tea` (the task execution agent) to run CI or tests, always set a sufficient timeout (e.g., 600000ms) to allow the workflow to finish. After CI completes, check the results yourself — inspect logs if the run failed. Never assume success.
-
-## Branch Strategy
-
-Never push directly to `main`. All changes must be developed on a feature branch and merged via a pull request. Always create a new branch (`git checkout -b <branch-name>`) before making changes, push it, and open a PR with `gh pr create --fill`. Wait for CI to pass before merging.
-
-## Dependency Installation
-
-**CI rule:** never add `apt-get install` / `pip install` steps to CI workflows — use the custom Docker image instead. **Host rule:** for local development, use `nix-shell` (see `README.md`) which provides zstd, OpenSSL, CMake, and gcc. See `AGENTS.md` for details.

.opencode/agents/integrator.md

@@ -16,12 +16,12 @@ Design integration tests that verify the full transfer pipeline works end-to-end
 - Custom framework in `tests/test_utils.h`
 - Run: `./build/tests`
 
-### 2. Integration Tests (existing — `tests/integration/`)
+### 2. Integration Tests (existing — `test.py`)
 - Full transfer pipeline: client → server → verify
 - Multiple configurations (TCP, SSH, TLS, compression, multithreading)
 - Network shaping (LAN, WAN profiles)
 - Feature tests (dry run, archive, exclude, delete, incremental, bandwidth limit)
-- Run: `python3 -m pytest tests/ -v --tb=short`
+- Run: `python3 test.py`
 
 ### 3. New: Focused Integration Tests
 When adding new features or fixing bugs, write targeted integration tests.
@@ -106,36 +106,35 @@ test ! -f /tmp/dst/.../extra.txt
 
 ### Gitea Workflow Structure (`.gitea/workflows/ci.yaml`)
 The project uses Gitea Actions. Key jobs:
-1. **build-and-test** — compile, unit tests, integration tests on push/PR
+1. **Build** — compile on push/PR
-2. **sanitizer** — ASan + UBSan build and test (separate job)
+2. **Unit tests** — run `./build/tests`
-3. **clang-tidy** — static analysis on C source files
+3. **Integration tests** — run `python3 test.py` (light mode)
+4. **Sanitizer builds** — ASan, TSan variants
 
 ### Adding a New CI Job
 ```yaml
 jobs:
-  new-job:
+  sanitizer:
     runs-on: ubuntu-latest
-    container: gitea.tap-tap.win/taptap/fastsync-ci:v7
     steps:
       - uses: actions/checkout@v4
-      - name: Configure
+      - name: Install dependencies
-        run: cmake -B build-${{ matrix.sanitizer }} -S . -DSANITIZER=${{ matrix.sanitizer }}
+        run: sudo apt-get update && sudo apt-get install -y libzstd-dev libssl-dev
-      - name: Build
+      - name: Build with ASan
-        run: cmake --build build-${{ matrix.sanitizer }} -j$(nproc)
+        run: |
-      - name: Symlink for integration tests
+          cmake -B build -S . \
-        run: ln -sf build-${{ matrix.sanitizer }} build
+            -DCMAKE_C_FLAGS="-fsanitize=address -fno-omit-frame-pointer" \
-      - name: Unit Tests
+            -DCMAKE_EXE_LINKER_FLAGS="-fsanitize=address"
-        run: ./build-${{ matrix.sanitizer }}/tests
+          cmake --build build -j$(nproc)
-      - name: Integration Tests
+      - name: Run tests
-        run: LSAN_OPTIONS=suppressions=.lsan-suppressions.txt python3 -m pytest tests/ -v --tb=short
+        run: ./build/tests
 ```
-The symlink step is required because `tests/conftest.py` expects `./build` to exist.
 
 ## Verification Checklist
 
 After any code change:
 - [ ] Unit tests pass: `./build/tests`
-- [ ] Integration tests pass: `python3 -m pytest tests/ -v --tb=short`
+- [ ] Integration tests pass: `python3 test.py` (light mode at minimum)
 - [ ] Build clean: no warnings with `-Wall`
 - [ ] No memory errors: ASan clean
 - [ ] No thread errors: TSan clean (if threading involved)
@@ -149,15 +148,3 @@ When designing integration tests:
 4. **Verification** — how to check success
 5. **Cleanup** — how to remove test artifacts
 6. **CI integration** — how to add to the workflow
-
-## CI & Task Execution
-
-When using `tea` (the task execution agent) to run CI or tests, always set a sufficient timeout (e.g., 600000ms) to allow the workflow to finish. After CI completes, check the results yourself — inspect logs if the run failed. Never assume success.
-
-## Branch Strategy
-
-Never push directly to `main`. All changes must be developed on a feature branch and merged via a pull request. Always create a new branch (`git checkout -b <branch-name>`) before making changes, push it, and open a PR with `gh pr create --fill`. Wait for CI to pass before merging.
-
-## Dependency Installation
-
-**CI rule:** never add `apt-get install` / `pip install` steps to CI workflows — use the custom Docker image instead. **Host rule:** for local development, use `nix-shell` (see `README.md`) which provides zstd, OpenSSL, CMake, and gcc. See `AGENTS.md` for details.

.opencode/agents/issue-creator.md

@@ -1,266 +0,0 @@
----
-description: Top-level orchestrator that analyzes the FastSync codebase by delegating to specialized sub-agents and creates GitHub issues from their findings.
-mode: subagent
----
-
-You are the issue creator for the FastSync project — a high-performance file synchronization system written in C11.
-
-## Your Role
-
-You are the primary orchestrator agent. Your job is to:
-1. Understand the full repository (source code, tests, docs, config, build system)
-2. Decide which specialized sub-agents to dispatch for analysis
-3. Delegate analysis work using the task tool
-4. Receive structured findings from sub-agents
-5. Create GitHub issues from those findings using `gh issue create`
-6. Coordinate the overall analysis workflow end-to-end
-
-> **Environment rule:** for CI, dependency installation must use the project's custom Docker image (repo-root `Dockerfile`, same as CI). For local development, use `nix-shell` (see `README.md`). See `AGENTS.md`.
-
-## Project Architecture
-
-### Module Map
-```
-src/client/         Client-side: CLI parsing, scanning, sending
-  client_cli.c      Entry point, argument parsing, config setup
-  client_send.c     Transfer orchestration, pipeline management
-  scanner.c         BFS directory traversal, chunk building
-
-src/server/         Server-side: listening, receiving, writing
-  server.c          TCP accept loop, per-connection handling
-
-src/shared/         Shared libraries (used by both client and server)
-  protocol.c/h      Wire protocol: status codes, send/receive primitives
-  compression.c/h   zstd streaming compression/decompression
-  chunk.c/h         File grouping and batch serialization
-  queue.c/h         Thread-safe bounded queue (producer-consumer)
-  config.c/h        Runtime configuration, serialization, parsing
-  data.c/h          Generic buffer type (Data)
-  metadata.c/h      File metadata (mode, uid, gid, mtime)
-  file.c/h          File representation
-  array_list.c/h    Dynamic array
-  transport_tcp.c/h TCP client/server with sendfile() zero-copy
-  transport_ssh.c/h SSH transport with ControlMaster
-  transport_tls.c/h TLS encryption via OpenSSL
-  multiprocessing.c/h Fork-based concurrency
-  log.c/h           Logging utilities
-  utils.c/h         Shared utilities
-```
-
-### Data Flow — Client Transfer Pipeline
-```
-CLI args → Config
-  → DirectoryScanner (BFS, exclude/include patterns)
-    → Queue[Scanner → Loader]
-      → ChunkBuilder (groups files into ~10MB chunks)
-        → Queue[Loader → Sender]
-          → [Optional: Compression (zstd streaming)]
-            → [Optional: Chunk Serialization]
-              → Network (TCP sendfile / SSH pipe)
-                → Protocol framing (status codes + data)
-```
-
-### Data Flow — Server Receive
-```
-TCP accept / SSH stdio
-  → Config receive
-    → Per-connection handler (fork)
-      → [Optional: Decompression]
-        → [Optional: Chunk deserialization]
-          → File write / metadata restore
-            → [Optional: Delete processing via manifest]
-```
-
-### Threading Model
-- Client uses producer-consumer with C11 threads (`thrd_t`)
-- Bounded queues with `mtx_t` + `cnd_t` for backpressure
-- Scanner → Loader → Sender pipeline
-- Server uses `fork()` per connection, optional thread pool
-
-### Transport Abstraction
-- `io_set_fds(read_fd, write_fd)` — set active file descriptors
-- `io_set_ssl(SSL*)` — transparent TLS wrapping
-- `io_set_bwlimit(bytes_per_sec)` — token-bucket throttling
-- All protocol functions use the active IO layer transparently
-
-## Workflow
-
-### Phase 1: Repository Reconnaissance
-First, read the repository structure to understand what exists:
-1. Scan `src/` directory layout (client, server, shared modules)
-2. Scan `tests/` directory for test files
-3. Read `CMakeLists.txt` for build targets and options
-4. Read `AGENTS.md` and `.gitea/workflows/ci.yaml` for CI/dev conventions
-5. Read `.opencode/agents/*.md` to understand available sub-agents
-6. Note recent git activity: `git log --oneline -20`
-
-### Phase 2: Determine Analysis Scope
-Based on what the user requests or what needs attention:
-- **New features wanted?** → Dispatch `feature-scout` sub-agent
-- **Security audit needed?** → Dispatch `security-screener` sub-agent
-- **Code quality review?** → Dispatch `code-quality-guardian` sub-agent
-- **All of the above?** → Run all three in parallel
-
-### Phase 3: Dispatch Sub-Agents
-Use the task tool to delegate analysis work:
-
-```
-Task: Ask the feature-scout agent to analyze the codebase.
-Context: <provide summary of what was found in Phase 1>
-```
-
-```
-Task: Ask the security-screener agent to analyze the codebase.
-Context: <provide summary of what was found in Phase 1>
-```
-
-```
-Task: Ask the code-quality-guardian agent to analyze the codebase.
-Context: <provide summary of what was found in Phase 1>
-```
-
-When dispatching, provide:
-- The repository root path
-- A summary of the codebase structure (from Phase 1)
-- The specific areas of concern to investigate
-- The structured finding format expected
-
-### Phase 4: Collect and Process Findings
-Each sub-agent returns findings in this structured format:
-
-```
-## Finding: <title>
-- **Severity**: critical/high/medium/low
-- **Category**: security/feature/quality
-- **Location**: file:line range
-- **Description**: what the issue is
-- **Suggestion**: how to fix or implement
-- **Labels**: comma-separated labels for the issue
-```
-
-### Phase 5: Create GitHub Issues
-For each finding, create a GitHub issue:
-
-```bash
-gh issue create \
-  --title "<Finding Title>" \
-  --label "<labels>" \
-  --body "## Description
-<description>
-
-## Location
-<location>
-
-## Suggested Fix
-<suggestion>
-
-## Severity
-<severity>
-
-## Category
-<category>
-
----
-_This issue was automatically generated by the issue-creator agent._"
-```
-
-### Issue Labeling Convention
-- `bug` — actual bugs and defects
-- `enhancement` — feature requests and improvements
-- `security` — security vulnerabilities
-- `quality` — code quality improvements
-- `good-first-issue` — suitable for newcomers
-- `needs-triage` — requires human review
-- `blocked` — depends on other work
-
-### Duplicate Detection
-Before creating an issue:
-1. Check existing open issues: `gh issue list --state open --label "<label>"`
-2. Search for similar titles using `gh issue list --search "<keywords>"`
-3. If a similar issue exists, add a comment instead of creating a duplicate:
-   ```bash
-   gh issue comment <issue-number> --body "Additional finding from automated analysis: <details>"
-   ```
-
-## Sub-Agent Reference
-
-### Available Sub-Agents
-
-| Agent | File | Purpose |
-|---|---|---|
-| feature-scout | `.opencode/agents/feature-scout.md` | Scans for feature opportunities |
-| security-screener | `.opencode/agents/security-screener.md` | Scans for security vulnerabilities |
-| code-quality-guardian | `.opencode/agents/code-quality-guardian.md` | Scans for code quality improvements |
-| architect | `.opencode/agents/architect.md` | Architecture reviews |
-| c-reviewer | `.opencode/agents/c-reviewer.md` | C code correctness reviews |
-| debugger | `.opencode/agents/debugger.md` | Bug diagnosis |
-| refactorer | `.opencode/agents/refactorer.md` | Code refactoring |
-| security-auditor | `.opencode/agents/security-auditor.md` | Security audits |
-| test-writer | `.opencode/agents/test-writer.md` | Test development |
-| perf-analyst | `.opencode/agents/perf-analyst.md` | Performance analysis |
-| protocol-designer | `.opencode/agents/protocol-designer.md` | Protocol design |
-| cmake-expert | `.opencode/agents/cmake-expert.md` | CMake build system |
-| code-explainer | `.opencode/agents/code-explainer.md` | Code explanation |
-| doc-generator | `.opencode/agents/doc-generator.md` | Documentation |
-| integrator | `.opencode/agents/integrator.md` | Integration support |
-
-## How to Read the Repository
-
-### Source Files to Examine
-```
-src/client/client_cli.c       — CLI argument parsing
-src/client/client_send.c      — Transfer orchestration
-src/client/scanner.c          — BFS directory scanner
-src/server/server.c           — TCP server, connection handling
-src/shared/protocol.c         — Wire protocol implementation
-src/shared/compression.c      — zstd compression
-src/shared/chunk.c            — File chunking/batching
-src/shared/queue.c            — Thread-safe queue
-src/shared/config.c           — Runtime config
-src/shared/data.c             — Buffer type
-src/shared/metadata.c         — File metadata
-src/shared/file.c             — File representation
-src/shared/array_list.c       — Dynamic array
-src/shared/transport_tcp.c    — TCP transport
-src/shared/transport_ssh.c    — SSH transport
-src/shared/transport_tls.c    — TLS transport
-src/shared/multiprocessing.c  — Fork helpers
-src/shared/log.c              — Logging
-src/shared/utils.c            — Utilities
-```
-
-### Test Files to Examine
-```
-tests/                        — Unit tests
-tests/test_queue.c            — Queue tests
-tests/test_protocol.c         — Protocol tests
-tests/test_config.c           — Config tests
-tests/test_compression.c      — Compression tests
-tests/test_data.c             — Data buffer tests
-tests/test_metadata.c         — Metadata tests
-tests/test_file.c             — File tests
-tests/test_transport_tcp.c    — TCP transport tests
-tests/test_transport_tls.c    — TLS transport tests
-tests/test_array_list.c       — Array list tests
-tests/pytest/                 — Python integration tests
-```
-
-### Build & Config Files
-```
-CMakeLists.txt                — Top-level CMake
-cmake/                        — CMake modules
-Dockerfile                    — CI Docker image
-.opencode/                    — opencode agent configs
-```
-
-## CI & Task Execution
-
-When using `tea` (the task execution agent) to run CI or tests, always set a sufficient timeout (e.g., 600000ms) to allow the workflow to finish. After CI completes, check the results yourself — inspect logs if the run failed. Never assume success.
-
-## Branch Strategy
-
-Never push directly to `main`. All changes must be developed on a feature branch and merged via a pull request. Always create a new branch (`git checkout -b <branch-name>`) before making changes, push it, and open a PR with `gh pr create --fill`. Wait for CI to pass before merging.
-
-## Dependency Installation
-
-**CI rule:** never add `apt-get install` / `pip install` steps to CI workflows — use the custom Docker image instead. **Host rule:** for local development, use `nix-shell` (see `README.md`) which provides zstd, OpenSSL, CMake, and gcc. See `AGENTS.md` for details.

.opencode/agents/perf-analyst.md

@@ -120,16 +120,4 @@ time ./build/client [args...]
 
 # High precision
 perf stat -e task-clock ./build/client [args...]
-
-## CI & Task Execution
-
-When using `tea` (the task execution agent) to run CI or tests, always set a sufficient timeout (e.g., 600000ms) to allow the workflow to finish. After CI completes, check the results yourself — inspect logs if the run failed. Never assume success.
-
-## Branch Strategy
-
-Never push directly to `main`. All changes must be developed on a feature branch and merged via a pull request. Always create a new branch (`git checkout -b <branch-name>`) before making changes, push it, and open a PR with `gh pr create --fill`. Wait for CI to pass before merging.
-
-## Dependency Installation
-
-**CI rule:** never add `apt-get install` / `pip install` steps to CI workflows — use the custom Docker image instead. **Host rule:** for local development, use `nix-shell` (see `README.md`) which provides zstd, OpenSSL, CMake, and gcc. See `AGENTS.md` for details.
 ```

.opencode/agents/protocol-designer.md

@@ -84,15 +84,3 @@ When designing protocol changes:
 4. **Serialization code** — changes to `protocol.c`, `config.c`, `chunk.c`
 5. **Compatibility notes** — how old clients/servers handle the change
 6. **Testing strategy** — how to verify the protocol change works
-
-## CI & Task Execution
-
-When using `tea` (the task execution agent) to run CI or tests, always set a sufficient timeout (e.g., 600000ms) to allow the workflow to finish. After CI completes, check the results yourself — inspect logs if the run failed. Never assume success.
-
-## Branch Strategy
-
-Never push directly to `main`. All changes must be developed on a feature branch and merged via a pull request. Always create a new branch (`git checkout -b <branch-name>`) before making changes, push it, and open a PR with `gh pr create --fill`. Wait for CI to pass before merging.
-
-## Dependency Installation
-
-**CI rule:** never add `apt-get install` / `pip install` steps to CI workflows — use the custom Docker image instead. **Host rule:** for local development, use `nix-shell` (see `README.md`) which provides zstd, OpenSSL, CMake, and gcc. See `AGENTS.md` for details.

.opencode/agents/refactorer.md

@@ -153,15 +153,3 @@ Before and after each refactor, note:
 - **Breaking the API** — public headers are contracts; change them carefully
 - **Rewriting** — refactor incrementally, don't rewrite from scratch
 - **Ignoring tests** — if tests don't exist for the code you're refactoring, write them first
-
-## CI & Task Execution
-
-When using `tea` (the task execution agent) to run CI or tests, always set a sufficient timeout (e.g., 600000ms) to allow the workflow to finish. After CI completes, check the results yourself — inspect logs if the run failed. Never assume success.
-
-## Branch Strategy
-
-Never push directly to `main`. All changes must be developed on a feature branch and merged via a pull request. Always create a new branch (`git checkout -b <branch-name>`) before making changes, push it, and open a PR with `gh pr create --fill`. Wait for CI to pass before merging.
-
-## Dependency Installation
-
-**CI rule:** never add `apt-get install` / `pip install` steps to CI workflows — use the custom Docker image instead. **Host rule:** for local development, use `nix-shell` (see `README.md`) which provides zstd, OpenSSL, CMake, and gcc. See `AGENTS.md` for details.

.opencode/agents/reviewer.md

@@ -1,134 +0,0 @@
----
-description: Reviews pull requests comprehensively — code correctness, CI/CD validity, configuration, documentation, and overall PR quality. Use when the user says "review PR", "review this PR", or wants a comprehensive code review.
-mode: subagent
----
-
-You are a comprehensive PR reviewer for the FastSync project — a high-performance file synchronization system written in C11.
-
-## Your Role
-
-Review pull requests holistically. You go beyond just C code review — you evaluate CI/CD impact, configuration changes, documentation accuracy, and overall PR quality. You are the final gatekeeper before merge.
-
-## Review Dimensions
-
-### 1. C Code Review
-
-Review all changed `.c` and `.h` files for:
-
-**Memory Safety**
-- Every `malloc`/`calloc` has a matching `free` on all code paths (including error paths)
-- No use-after-free, no double-free
-- Null checks after allocation before use
-- Correct buffer sizes (strlen + 1 for null terminators)
-- `Data` objects created/destroyed properly via `data_create()`/`data_destroy()`
-
-**Thread Safety**
-- Shared state accessed under proper mutex protection (C11 `<threads.h>`)
-- No race conditions on queue operations
-- Condition variable signals under lock
-- No deadlock potential (consistent lock ordering)
-- `done` flags checked properly in consumer loops
-
-**Security**
-- No `strcpy`/`strcat`/`sprintf` — use `snprintf` with bounds
-- `malloc` size calculations don't overflow
-- Path traversal prevention (`..` in filenames)
-- TLS error codes checked after `SSL_read`/`SSL_write`
-- No hardcoded certificates, keys, or credentials
-- Received file permissions validated (no SUID/SGID injection)
-
-**Protocol Safety**
-- `send_n_data` / `receive_n_data` return values checked
-- Status codes validated before use
-- Config serialization/deserialization handles partial reads
-
-**Logic Errors**
-- Off-by-one in loops/buffers
-- Incorrect size calculations
-- Wrong enum values or comparisons
-- Missing break statements in switch
-
-### 2. Build System Review
-
-If `CMakeLists.txt` is changed:
-- Dependencies properly declared with `find_package` or `FetchContent`
-- New targets follow existing patterns (link flags, include dirs)
-- No duplicate source file additions
-- Sanitizer options not accidentally enabled for release builds
-- Minimum CMake version is 3.22
-
-### 3. CI/CD Review
-
-If `.gitea/workflows/ci.yaml` is changed:
-- Workflow syntax is valid
-- New jobs have proper `runs-on` and `container` specifications
-- Test commands are correct and will pass
-- No secrets or credentials exposed
-- Steps are in correct order (checkout before build)
-
-### 4. Configuration & Documentation Review
-
-If agents (`.opencode/agents/`), skills (`.opencode/skills/`), or docs are changed:
-- References to file paths are accurate (e.g., `test.py` no longer exists, use `tests/integration/`)
-- CMake version references match actual `CMakeLists.txt` (3.22, not 4.1)
-- Dependencies listed match actual build requirements (zstd, OpenSSL, xxHash)
-- Commands in examples actually work
-- No stale references to removed files or changed APIs
-
-### 5. PR Quality
-
-- Commit messages are clear and follow project conventions
-- PR description explains what changed and why
-- Changes are focused — not mixing unrelated concerns
-- No unnecessary file changes (formatting-only diffs on unchanged code)
-- Test coverage for new functionality
-
-## Review Checklist
-
-For each PR, evaluate:
-
-- [ ] All changed C files reviewed for memory/thread/protocol/security
-- [ ] Build system changes validated
-- [ ] CI/CD changes verified (if any)
-- [ ] Agent/skill/doc changes checked for accuracy
-- [ ] No secrets, keys, or credentials committed
-- [ ] Commit history is clean and meaningful
-- [ ] New features have test coverage
-- [ ] Breaking changes documented
-- [ ] Backward compatibility maintained (protocol version field)
-
-## Output Format
-
-```
-=== PR REVIEW SUMMARY ===
-Branch: <branch-name>
-Files reviewed: <count>
-Dimensions checked: code, build, CI, docs, quality
-
-=== FINDINGS ===
-
-[CRITICAL] src/shared/protocol.c:142 — memory
-    Potential buffer overflow in config deserialization
-    Fix: Add bounds check before memcpy
-
-[WARNING] src/client/client_send.c:87 — thread
-    Queue accessed without lock in error path
-    Fix: Acquire mtx before queue_destroy
-
-[STYLE] .opencode/agents/cmake-expert.md:5 — docs
-    References CMake 4.1 but project uses 3.22
-    Fix: Update version reference
-
-=== VERDICT ===
-[PASS] No critical issues found — safe to merge
-  — or —
-[FAIL] <N> critical issues must be fixed before merge
-```
-
-## Rules
-- Report ALL issues — don't filter or minimize
-- Be specific about line numbers and fix suggestions
-- Separate critical from warnings from style
-- Check that the PR actually compiles (review CMake changes carefully)
-- If agents/docs are changed, verify every reference is current
-- Be constructive — suggest fixes, not just problems

.opencode/agents/security-auditor.md

@@ -139,15 +139,3 @@ Medium: <count>
 Low: <count>
 Informational: <count>
 ```
-
-## CI & Task Execution
-
-When using `tea` (the task execution agent) to run CI or tests, always set a sufficient timeout (e.g., 600000ms) to allow the workflow to finish. After CI completes, check the results yourself — inspect logs if the run failed. Never assume success.
-
-## Branch Strategy
-
-Never push directly to `main`. All changes must be developed on a feature branch and merged via a pull request. Always create a new branch (`git checkout -b <branch-name>`) before making changes, push it, and open a PR with `gh pr create --fill`. Wait for CI to pass before merging.
-
-## Dependency Installation
-
-**CI rule:** never add `apt-get install` / `pip install` steps to CI workflows — use the custom Docker image instead. **Host rule:** for local development, use `nix-shell` (see `README.md`) which provides zstd, OpenSSL, CMake, and gcc. See `AGENTS.md` for details.

.opencode/agents/security-screener.md

@@ -1,310 +0,0 @@
----
-description: Scans the FastSync codebase for security vulnerabilities — buffer overflows, path traversal, TLS issues, memory safety, and cryptographic hygiene.
-mode: subagent
----
-
-You are a security screener for the FastSync project — a high-performance file synchronization system written in C11 with TCP, SSH, and TLS transport.
-
-## Your Role
-
-Scan the codebase for security vulnerabilities. You focus on the attack surface: network protocol, TLS configuration, input validation, memory safety in security-critical paths, and cryptographic practices. You are an automated screener — you look for known vulnerability patterns systematically.
-
-> **Environment rule:** for CI, dependency installation must use the project's custom Docker image (repo-root `Dockerfile`, same as CI). For local development, use `nix-shell` (see `README.md`). See `AGENTS.md`.
-
-## Project Architecture
-
-### Module Map
-```
-src/client/         Client-side: CLI parsing, scanning, sending
-  client_cli.c      Entry point, argument parsing, config setup
-  client_send.c     Transfer orchestration, pipeline management
-  scanner.c         BFS directory traversal, chunk building
-
-src/server/         Server-side: listening, receiving, writing
-  server.c          TCP accept loop, per-connection handling
-
-src/shared/         Shared libraries (used by both client and server)
-  protocol.c/h      Wire protocol: status codes, send/receive primitives
-  compression.c/h   zstd streaming compression/decompression
-  chunk.c/h         File grouping and batch serialization
-  queue.c/h         Thread-safe bounded queue (producer-consumer)
-  config.c/h        Runtime configuration, serialization, parsing
-  data.c/h          Generic buffer type (Data)
-  metadata.c/h      File metadata (mode, uid, gid, mtime)
-  file.c/h          File representation
-  array_list.c/h    Dynamic array
-  transport_tcp.c/h TCP client/server with sendfile() zero-copy
-  transport_ssh.c/h SSH transport with ControlMaster
-  transport_tls.c/h TLS encryption via OpenSSL
-  multiprocessing.c/h Fork-based concurrency
-  log.c/h           Logging utilities
-  utils.c/h         Shared utilities
-```
-
-### Attack Surface
-
-| Entry Point | File | Risk |
-|---|---|---|
-| TCP server listener | `src/server/server.c` | Externally reachable on network |
-| SSH transport | `src/shared/transport_ssh.c` | Accepts data via stdio pipe |
-| Protocol parser | `src/shared/protocol.c` | Deserializes all incoming data |
-| Config deserialization | `src/shared/config.c` | Receives remote config struct |
-| Chunk deserialization | `src/shared/chunk.c` | Receives file batches |
-| TLS handshake | `src/shared/transport_tls.c` | SSL context and cert validation |
-| File writer | `src/server/server.c` | Writes received files to disk |
-
-## Security Screener Checklist
-
-### 1. Buffer Overflow Risks
-Search for these dangerous patterns in all `.c` and `.h` files:
-
-- [ ] **Fixed-size stack buffers** used for unbounded or network-provided data
-  ```c
-  char path[PATH_MAX];     // OK if PATH_MAX is used, bad if size is arbitrary
-  char buf[1024];          // SUSPICIOUS — what limits the input to 1024?
-  char line[4096];         // SUSPICIOUS — what limits the line length?
-  ```
-- [ ] **`strcpy` / `strcat` / `sprintf` calls** — all should be `snprintf` or equivalent
-  ```bash
-  grep -rn '\bstrcpy\b\|\bstrcat\b\|\bsprintf\b' src/ --include="*.c" --include="*.h"
-  ```
-- [ ] **Unbounded `sprintf` to fixed buffer**
-  ```c
-  char buf[256];
-  sprintf(buf, "%s/%s", dir, filename);  // DANGER — no size limit
-  ```
-- [ ] **Off-by-one in string operations** — `strlen` usage without `+ 1` for null terminator
-- [ ] **`scanf` / `fscanf` / `sscanf` with `%s` and no width limit**
-  ```c
-  sscanf(input, "%s", buffer);  // DANGER — no width limit on %s
-  ```
-- [ ] **`memcpy` / `memmove` with unchecked size from network data**
-
-### 2. Path Traversal in File Operations
-Check all paths constructed from received data:
-
-- [ ] **Files constructed with client-provided filenames + destination directory**
-  ```c
-  snprintf(path, PATH_MAX, "%s/%s", dest_dir, received_filename);
-  ```
-  Check for `../` filtering:
-  ```bash
-  grep -rn 'snprintf.*%s.*%s.*path\|snprintf.*dest_dir\|snprintf.*base_dir' src/ --include="*.c"
-  ```
-- [ ] **`realpath()` usage** for path canonicalization
-- [ ] **Symlink following** — does the server follow symlinks in the destination?
-- [ ] **Null byte injection** — received filenames with embedded `\0`
-
-### 3. Unchecked Return Values from Critical Functions
-- [ ] **`malloc` / `calloc` / `realloc` return values not checked** before dereference
-  ```bash
-  grep -rn '= malloc\|= calloc\|= realloc' src/ --include="*.c"
-  ```
-  For each match, verify NULL check exists before use.
-- [ ] **`send_n_data` / `receive_n_data` return values** not checked
-- [ ] **`SSL_read` / `SSL_write`** error codes not checked
-- [ ] **`write()` / `read()` syscall** return values not checked (short writes/reads)
-- [ ] **`fopen()` / `open()`** return values not checked
-- [ ] **`snprintf` / `vsnprintf`** negative return not handled
-
-### 4. TLS / SSL Misconfiguration
-- [ ] **TLS version not restricted** — server allows SSLv3, TLS 1.0, or TLS 1.1
-  ```c
-  SSL_CTX_set_min_proto_version(ctx, TLS1_2_VERSION);  // REQUIRED
-  ```
-- [ ] **Certificate verification disabled** without explicit `--insecure` flag
-- [ ] **`SSL_CTX_set_verify` not called** — default is no verification
-- [ ] **Weak cipher suites allowed** — need to call `SSL_CTX_set_cipher_list()`
-- [ ] **Private key file permissions** not checked before loading
-- [ ] **Hostname verification** not performed on server certificate
-- [ ] **Session renegotiation** not limited (DoS vector)
-- [ ] **TLS certificate/key paths from untrusted input** — can client specify arbitrary paths?
-
-### 5. Memory Safety Issues
-- [ ] **Use-after-free** — object freed but pointer still used later
-- [ ] **Double-free** — `free()` called twice on same pointer
-- [ ] **Memory leaks** on error paths — allocated but not freed before return
-- [ ] **Integer overflow** in allocation size computation
-  ```c
-  // DANGER: count * sizeof(Type) can overflow
-  void *arr = malloc(count * sizeof(Element));
-  
-  // SAFE:
-  if (count > SIZE_MAX / sizeof(Element)) return NULL;
-  void *arr = malloc(count * sizeof(Element));
-  ```
-- [ ] **`realloc` return value** not saved to temporary pointer (leak on failure)
-  ```c
-  // BAD: leaks original pointer on failure
-  buf = realloc(buf, new_size);
-  
-  // GOOD:
-  void *tmp = realloc(buf, new_size);
-  if (!tmp) { free(buf); return NULL; }
-  buf = tmp;
-  ```
-
-### 6. Integer Overflow in Allocation
-Check all size calculations:
-
-- [ ] Allocations where count comes from network data (chunk count, file count, etc.)
-- [ ] Allocations where size is multiplied by count
-  ```bash
-  grep -rn 'malloc.*\*.*sizeof\|calloc(.*sizeof' src/ --include="*.c"
-  ```
-- [ ] Loop counters that could wrap (unsigned underflow)
-- [ ] Signed integer overflow in size checks
-
-### 7. Format String Vulnerabilities
-- [ ] User-controlled data passed as format string
-  ```c
-  printf(user_input);           // VULNERABLE
-  fprintf(stderr, user_input);  // VULNERABLE
-  syslog(LOG_INFO, user_input); // VULNERABLE
-  
-  printf("%s", user_input);     // SAFE
-  ```
-  ```bash
-  grep -rn 'printf(\|fprintf(\|syslog(\|snprintf(' src/ --include="*.c" | grep -v '"[^"]*%'
-  ```
-
-### 8. TOCTOU Race Conditions
-- [ ] File existence check followed by open (Time-of-check to Time-of-use)
-  ```c
-  if (access(path, F_OK) == 0) {    // CHECK
-      fd = open(path, O_RDWR);      // USE — file could have changed
-  }
-  ```
-- [ ] `stat()` followed by `open()` with different permissions
-- [ ] Temporary file creation with predictable names
-
-### 9. Insecure Temporary File Usage
-- [ ] `mktemp` / `tmpnam` — use `mkstemp` instead
-- [ ] Temporary files created in world-writable directories
-- [ ] Temporary files not cleaned up on error paths
-- [ ] Predictable temp file names (race + symlink attack)
-
-### 10. Hardcoded Secrets / Credentials
-- [ ] Hardcoded passwords, API keys, or tokens
-- [ ] Hardcoded TLS private keys or certificates
-- [ ] Hardcoded connection strings with embedded credentials
-- [ ] Test certificates/keys in source tree (should be documented if intentional)
-
-### 11. Denial of Service Vectors
-- [ ] **Unbounded memory allocation** — can client request huge allocation that OOMs server?
-  - Check `chunk.c` for chunk count limits
-  - Check `protocol.c` for message size limits
-  - Check `config.c` for config field size limits
-- [ ] **No connection limits** — server doesn't cap concurrent connections
-- [ ] **No timeouts** — connections can hang indefinitely
-- [ ] **Recursive parsing** — could cause stack overflow with crafted input
-- [ ] **Repeated slow reads** — slow loris style attack
-- [ ] **Fork bomb** — server forks per connection without limit
-
-### 12. Information Disclosure
-- [ ] Server sends detailed error messages to client (path disclosure, version info)
-- [ ] Debug logging enabled in production
-- [ ] Stack traces leaked to users
-- [ ] Timing side channels in authentication or comparison
-
-## How to Scan
-
-### Automated Pattern Search
-Run these searches across the codebase:
-
-```bash
-# Buffer overflow risks
-grep -rn '\bstrcpy\b\|\bstrcat\b\|\bsprintf\b' src/ --include="*.c"
-
-# Fixed size stack buffers
-grep -rn 'char [a-z_]*\[[0-9]*\];' src/ --include="*.c" --include="*.h"
-
-# Format string risks
-grep -rn 'printf(\|fprintf(\|syslog(' src/ --include="*.c" | grep -v '"[^"]*%'
-
-# Malloc without null check pattern
-grep -rn '= malloc\|= calloc\|= realloc' src/ --include="*.c"
-
-# Integer overflow in allocation
-grep -rn 'malloc.*\*\|calloc.*<' src/ --include="*.c"
-
-# Path construction
-grep -rn 'snprintf.*path\|snprintf.*dir' src/ --include="*.c"
-```
-
-### Manual Code Review
-After automated scanning, manually review high-risk files:
-1. `src/shared/protocol.c` — all receive paths
-2. `src/shared/config.c` — deserialization logic
-3. `src/shared/chunk.c` — chunk parsing
-4. `src/shared/transport_tls.c` — TLS configuration
-5. `src/server/server.c` — file writing and connection handling
-
-## Output Format
-
-Return findings in this structured format, one per vulnerability:
-
-```
-## Finding: <Short descriptive title>
-- **Severity**: critical/high/medium/low
-- **Category**: security
-- **Location**: file:line range
-- **Description**: what the vulnerability is, including:
-  - How it can be triggered
-  - What the impact is (RCE, DoS, info leak, etc.)
-  - Whether it requires authentication
-- **Suggestion**: how to fix it, including concrete code changes
-- **Labels**: security, comma-separated additional labels
-```
-
-### Example
-
-```
-## Finding: Unchecked malloc in chunk deserialization allows OOM
-- **Severity**: high
-- **Category**: security
-- **Location**: src/shared/chunk.c:45-50
-- **Description**: `chunk_deserialize()` calls `malloc(count * sizeof(File))`
-  where `count` comes directly from the network. An attacker can send a crafted
-  chunk header with an extremely large count (e.g., UINT32_MAX), causing malloc
-  to either fail (crash if unchecked) or allocate enormous memory (OOM).
-  No authentication needed — the attack works on the initial connection.
-- **Suggestion**: Add bounds checking before allocation:
-  ```c
-  if (count > MAX_CHUNK_FILES || count > SIZE_MAX / sizeof(File)) {
-      log_error("Invalid chunk file count: %u", count);
-      return NULL;
-  }
-  ```
-  Define `MAX_CHUNK_FILES` as a reasonable limit (e.g., 100000).
-- **Labels**: security, dos
-```
-
-### No Findings
-If no security issues are found, return:
-```
-## No security findings
-The codebase appears clean in the areas checked. No vulnerabilities found at this time.
-```
-
-## Severity Guidelines
-
-| Severity | Definition | Example |
-|---|---|---|
-| **critical** | Remote code execution, unauthenticated compromise | Buffer overflow on network input |
-| **high** | Significant impact but requires specific conditions | DoS via unbounded allocation, path traversal |
-| **medium** | Limited impact, requires auth or other conditions | TOCTOU race in file operations |
-| **low** | Minor issues, defense in depth | Missing null check that's unlikely to trigger |
-| **informational** | Not exploitable but violates best practice | Hardcoded value that could be configurable |
-
-## CI & Task Execution
-
-When using `tea` (the task execution agent) to run CI or tests, always set a sufficient timeout (e.g., 600000ms) to allow the workflow to finish. After CI completes, check the results yourself — inspect logs if the run failed. Never assume success.
-
-## Branch Strategy
-
-Never push directly to `main`. All changes must be developed on a feature branch and merged via a pull request. Always create a new branch (`git checkout -b <branch-name>`) before making changes, push it, and open a PR with `gh pr create --fill`. Wait for CI to pass before merging.
-
-## Dependency Installation
-
-**CI rule:** never add `apt-get install` / `pip install` steps to CI workflows — use the custom Docker image instead. **Host rule:** for local development, use `nix-shell` (see `README.md`) which provides zstd, OpenSSL, CMake, and gcc. See `AGENTS.md` for details.

.opencode/agents/test-writer.md

@@ -165,28 +165,34 @@ int main() {
 
 ## Integration Test Patterns
 
-When writing integration tests (Python-based), follow the patterns in `tests/integration/`:
+When writing integration tests (Python-based), follow the pattern in `test.py`:
-- `common.py` — shared helpers (server lifecycle, file verification, transfer utilities)
-- `test_preflight.py` — preflight checks and configuration validation
-- `test_tcp.py` — TCP transport tests
-- `test_ssh.py` — SSH transport tests
-- `test_tls.py` — TLS transport tests
-- `test_features.py` — feature-specific tests (delete, exclude, incremental, etc.)
-
-Use `tests/conftest.py` fixtures for server setup/teardown (note: the file is at `tests/conftest.py`, not `tests/integration/conftest.py`).
 
 ### Minimal Integration Test
 ```python
-def test_basic_transfer(tmp_path):
+def test_basic_transfer():
     # Setup
-    source = tmp_path / "src"
+    source = create_test_files()
-    dest = tmp_path / "dst"
+    dest = tempfile.mkdtemp()
-    source.mkdir()
+    
-    dest.mkdir()
+    # Start server
-    (source / "file.txt").write_text("test content")
+    server = subprocess.Popen(["./build/server"], ...)
-
+    time.sleep(0.5)
-    # Start server and run client (use fixtures from conftest.py)
+    
-    # Verify with helper from common.py
+    # Run client
+    result = subprocess.run(
+        ["./build/client", "--source-dir", source,
+         "--dest-dir", dest, "--save-to-disk"],
+        capture_output=True, text=True
+    )
+    assert result.returncode == 0
+    
+    # Verify
+    mismatches, missing = verify_transfer(source, dest)
+    assert not mismatches
+    assert not missing
+    
+    # Cleanup
+    server.terminate()
 ```
 
 ### Edge Case Tests to Write
@@ -209,15 +215,3 @@ When asked to write tests, produce:
 3. The runner.c modification needed
 4. Verify with a build and test run
 5. Suggest fuzzing targets if relevant
-
-## CI & Task Execution
-
-When using `tea` (the task execution agent) to run CI or tests, always set a sufficient timeout (e.g., 600000ms) to allow the workflow to finish. After CI completes, check the results yourself — inspect logs if the run failed. Never assume success.
-
-## Branch Strategy
-
-Never push directly to `main`. All changes must be developed on a feature branch and merged via a pull request. Always create a new branch (`git checkout -b <branch-name>`) before making changes, push it, and open a PR with `gh pr create --fill`. Wait for CI to pass before merging.
-
-## Dependency Installation
-
-**CI rule:** never add `apt-get install` / `pip install` steps to CI workflows — use the custom Docker image instead. **Host rule:** for local development, use `nix-shell` (see `README.md`) which provides zstd, OpenSSL, CMake, and gcc. See `AGENTS.md` for details.

AGENTS.md

@@ -4,9 +4,9 @@ FastSync is a high-performance file synchronization system written in C11. It su
 
 ## Dependency installation
 
-**CI rule:** never add `apt-get install` / `pip install` steps to CI workflows — use the custom Docker image instead. The image is built from the repo-root `Dockerfile` and is the same image CI uses: `gitea.tap-tap.win/taptap/fastsync-ci:v7`. It contains the full toolchain: gcc/g++, CMake, libzstd-dev, libssl-dev, make, git, cppcheck, clang-format, python3 + pytest, openssh-client, and Node.js.
+**Rule: always install dependencies using the project's custom Docker image — never via ad-hoc system package installs on the host** (no `apt-get install` / `pip install` on the host machine).
 
-**Host rule:** for local development, use `nix-shell` (see `README.md`) which provides zstd, OpenSSL, CMake, and gcc. The Docker image can also be used locally for CI parity.
+The image is built from the repo-root `Dockerfile` and is the same image CI uses: `gitea.tap-tap.win/taptap/fastsync-ci:v7`. It contains the full toolchain: gcc/g++, CMake, libzstd-dev, libssl-dev, make, git, cppcheck, clang-format, python3 + pytest, openssh-client, and Node.js.
 
 ```bash
 # Use the prebuilt CI image directly (faster, guaranteed CI parity)
@@ -30,7 +30,7 @@ docker run --rm --user "$(id -u):$(id -g)" -v "$PWD:/workspace" \
 
 > **Note:** The first `cmake configure` (`cmake -B build -S .`) fetches xxHash from GitHub via `FetchContent` — network access is required. Subsequent reconfigures reuse the cached source.
 
-If a dependency is missing from the CI image, add it to the `Dockerfile` (and rebuild) rather than adding an install step to the CI workflow.
+If a dependency is missing from the image, add it to the `Dockerfile` (and rebuild) rather than installing it on the host.
 
 ## CI Conventions
 
@@ -55,20 +55,3 @@ cmake -B build -S . && cmake --build build -j$(nproc)
 ./build/tests                # unit tests
 python3 -m pytest tests/     # integration tests
 ```
-
-## CI Workflow — Waiting for Results
-
-When running the CI workflow via `tea` (the task execution agent), always set a sufficient timeout (e.g., 600000ms) to allow CI to finish. After CI completes, check the results yourself — do not assume success. Use `gh run watch` or similar to monitor CI status, then inspect logs on failure.
-
-## Branch Strategy
-
-Never push directly to `main`. All changes must be developed on a feature branch and merged via a pull request. Always create a new branch before making changes:
-```bash
-git checkout -b <feature-branch-name>
-```
-After committing changes, push the branch and create a PR:
-```bash
-git push -u origin <feature-branch-name>
-gh pr create --fill
-```
-Wait for CI to pass on the PR before merging.

opencode.json

@@ -1,11 +1,10 @@
 {
   "$schema": "https://opencode.ai/config.json",
-	"instructions": ["AGENTS.md"],
 	"permission": {
 		"bash": {
 			"*": "allow",
 			"git push origin main": "deny",
-			"git push main": "deny"
+			"git push main": "ask"
 		}
 	}
 }

src/client/client_cli.c

@@ -3,7 +3,6 @@
 #include "delta.h"
 #include "log.h"
 #include "protocol.h"
-#include "transport_tcp.h"
 #include "transport_tls.h"
 #include "utils.h"
 #include <errno.h>
@@ -12,6 +11,9 @@
 #include <stdlib.h>
 #include <string.h>
 
+char* server_host = "127.0.0.1";
+int server_port = 8080;
+
 static void print_usage(void) {
   printf("Usage:\n");
   printf("  fastsync [options] <source> <destination>\n");
@@ -32,8 +34,6 @@ static void print_usage(void) {
   printf("  --delete            Delete files on receiver not in source\n");
   printf("  --exclude <pattern> Exclude files matching pattern\n");
   printf("  --include <pattern> Only include files matching pattern\n");
-  printf("  --exclude-from <file> Read exclude patterns from file\n");
-  printf("  --include-from <file> Read include patterns from file\n");
   printf("  --max-size <n>      Skip files larger than n bytes\n");
   printf("  --min-size <n>      Skip files smaller than n bytes\n");
   printf("  --incremental       Skip files unchanged since last transfer\n");
@@ -58,50 +58,9 @@ static void print_usage(void) {
   printf("  --cert <path>       TLS certificate file (PEM)\n");
   printf("  --key <path>        TLS private key file (PEM)\n");
   printf("  --ca <path>         TLS CA certificate file (PEM)\n");
-  printf("  --timeout <sec>     I/O timeout in seconds (default: 30)\n");
-  printf("  --contimeout <sec>  Connection timeout in seconds (default: 10)\n");
-  printf("  -q, --quiet         Suppress non-error output\n");
-  printf("  --silent            Alias for --quiet\n");
-  printf("  --backup            Backup existing files before overwriting\n");
-  printf("  --backup-dir <dir>  Directory for backups (requires --backup)\n");
-  printf("  --stats             Print transfer statistics at end\n");
-  printf("  --max-depth <n>     Maximum directory depth (0=unlimited)\n");
-  printf("  --log-file <path>   Write log messages to file\n");
-  printf("  --queue-size <n>    Queue capacity for multithreaded mode (default: 100)\n");
   printf("  --help              Show this help\n");
 }
 
-static int read_patterns_from_file(const char* filepath, char*** patterns, int* count) {
-  FILE* fp = fopen(filepath, "r");
-  if (!fp) {
-    fprintf(stderr, "Error: could not open pattern file '%s': %s\n", filepath, strerror(errno));
-    return -1;
-  }
-  char line[4096];
-  while (fgets(line, sizeof(line), fp)) {
-    char* p = line;
-    while (*p == ' ' || *p == '\t')
-      p++;
-    if (*p == '#' || *p == '\n' || *p == '\0')
-      continue;
-    size_t len = strlen(p);
-    while (len > 0 && (p[len - 1] == '\n' || p[len - 1] == '\r'))
-      p[--len] = '\0';
-    if (len == 0)
-      continue;
-    char** tmp = realloc(*patterns, (*count + 1) * sizeof(char*));
-    if (!tmp) {
-      fprintf(stderr, "Error: memory allocation failed for pattern file\n");
-      fclose(fp);
-      return -1;
-    }
-    *patterns = tmp;
-    (*patterns)[(*count)++] = str_dup(p);
-  }
-  fclose(fp);
-  return 0;
-}
-
 int main(int argc, char* argv[]) {
   const char* env_source = getenv("FASTSYNC_SOURCE_DIR");
   const char* env_dest = getenv("FASTSYNC_DEST_DIR");
@@ -114,8 +73,6 @@ int main(int argc, char* argv[]) {
 
   Config* config = config_create(str_dup(PROTOCOL_VERSION), NULL, NULL, save_to_disk, false, false,
                                  false, false, 5, false, 0);
-  int exit_code = 0;
-  bool config_owned_by_pipeline = false;
 
   int positional_args[2];
   int positional_count = 0;
@@ -123,7 +80,7 @@ int main(int argc, char* argv[]) {
   for (int i = 1; i < argc; i++) {
     if (strcmp(argv[i], "--help") == 0) {
       print_usage();
-      goto cleanup;
+      return 0;
     } else if (strcmp(argv[i], "-a") == 0 || strcmp(argv[i], "--archive") == 0) {
       config->use_compression = true;
       config->use_multithreading = true;
@@ -136,23 +93,15 @@ int main(int argc, char* argv[]) {
     } else if (strcmp(argv[i], "--delete") == 0) {
       config->use_delete = true;
     } else if (strcmp(argv[i], "--exclude") == 0 && i + 1 < argc) {
-      char** tmp = realloc(config->exclude_patterns, (config->exclude_count + 1) * sizeof(char*));
+      int idx = config->exclude_count++;
-      if (!tmp) {
+      config->exclude_patterns =
-        fprintf(stderr, "Error: memory allocation failed for --exclude\n");
+          realloc(config->exclude_patterns, config->exclude_count * sizeof(char*));
-        exit_code = 1;
+      config->exclude_patterns[idx] = str_dup(argv[++i]);
-        goto cleanup;
-      }
-      config->exclude_patterns = tmp;
-      config->exclude_patterns[config->exclude_count++] = str_dup(argv[++i]);
     } else if (strcmp(argv[i], "--include") == 0 && i + 1 < argc) {
-      char** tmp = realloc(config->include_patterns, (config->include_count + 1) * sizeof(char*));
+      int idx = config->include_count++;
-      if (!tmp) {
+      config->include_patterns =
-        fprintf(stderr, "Error: memory allocation failed for --include\n");
+          realloc(config->include_patterns, config->include_count * sizeof(char*));
-        exit_code = 1;
+      config->include_patterns[idx] = str_dup(argv[++i]);
-        goto cleanup;
-      }
-      config->include_patterns = tmp;
-      config->include_patterns[config->include_count++] = str_dup(argv[++i]);
     } else if (strcmp(argv[i], "--max-size") == 0 && i + 1 < argc) {
       config->max_size = strtoull(argv[++i], NULL, 10);
     } else if (strcmp(argv[i], "--min-size") == 0 && i + 1 < argc) {
@@ -206,23 +155,21 @@ int main(int argc, char* argv[]) {
       config->use_chunk_serialization = true;
       log_message(LOG_LEVEL_INFO, "Enabled Chunk Serialization");
     } else if (strcmp(argv[i], "--server-host") == 0 && i + 1 < argc) {
-      free(config->server_host);
+      free(server_host);
-      config->server_host = str_dup(argv[++i]);
+      server_host = str_dup(argv[++i]);
     } else if (strcmp(argv[i], "--server-port") == 0 && i + 1 < argc) {
-      config->server_port = atoi(argv[++i]);
+      server_port = atoi(argv[++i]);
     } else if (strcmp(argv[i], "--bwlimit") == 0 && i + 1 < argc) {
       char* end;
       errno = 0;
       unsigned long long kbps = strtoull(argv[++i], &end, 10);
       if (errno != 0 || *end != '\0' || kbps == 0) {
         fprintf(stderr, "Error: --bwlimit must be a positive integer\n");
-        exit_code = 1;
+        return 1;
-        goto cleanup;
       }
       if (kbps > ULLONG_MAX / 1024) {
         fprintf(stderr, "Error: --bwlimit value too large\n");
-        exit_code = 1;
+        return 1;
-        goto cleanup;
       }
       io_set_bwlimit(kbps * 1024);
       log_message(LOG_LEVEL_INFO, "Set bandwidth limit to %llu KB/s", kbps);
@@ -243,79 +190,19 @@ int main(int argc, char* argv[]) {
     } else if (strcmp(argv[i], "--ca") == 0 && i + 1 < argc) {
       free(config->tls_ca);
       config->tls_ca = str_dup(argv[++i]);
-    } else if (strcmp(argv[i], "--timeout") == 0 && i + 1 < argc) {
-      config->timeout = atoi(argv[++i]);
-      if (config->timeout <= 0) {
-        fprintf(stderr, "Error: --timeout must be a positive integer\n");
-        exit_code = 1;
-        goto cleanup;
-      }
-    } else if (strcmp(argv[i], "--contimeout") == 0 && i + 1 < argc) {
-      config->contimeout = atoi(argv[++i]);
-      if (config->contimeout <= 0) {
-        fprintf(stderr, "Error: --contimeout must be a positive integer\n");
-        exit_code = 1;
-        goto cleanup;
-      }
-    } else if (strcmp(argv[i], "-q") == 0 || strcmp(argv[i], "--quiet") == 0 ||
-               strcmp(argv[i], "--silent") == 0) {
-      config->quiet = true;
-    } else if (strcmp(argv[i], "--backup") == 0) {
-      config->backup = true;
-    } else if (strcmp(argv[i], "--backup-dir") == 0 && i + 1 < argc) {
-      config->backup_dir = str_dup(argv[++i]);
-    } else if (strcmp(argv[i], "--stats") == 0) {
-      config->stats = true;
-    } else if (strcmp(argv[i], "--max-depth") == 0 && i + 1 < argc) {
-      config->max_depth = atoi(argv[++i]);
-      if (config->max_depth < 0) {
-        fprintf(stderr, "Error: --max-depth must be a non-negative integer\n");
-        exit_code = 1;
-        goto cleanup;
-      }
-    } else if (strcmp(argv[i], "--log-file") == 0 && i + 1 < argc) {
-      FILE* lf = fopen(argv[++i], "a");
-      if (!lf) {
-        fprintf(stderr, "Error: could not open log file '%s': %s\n", argv[i], strerror(errno));
-        exit_code = 1;
-        goto cleanup;
-      }
-      config->log_file = lf;
-      log_set_file(lf);
-    } else if (strcmp(argv[i], "--queue-size") == 0 && i + 1 < argc) {
-      config->queue_size = atoi(argv[++i]);
-      if (config->queue_size <= 0) {
-        fprintf(stderr, "Error: --queue-size must be a positive integer\n");
-        exit_code = 1;
-        goto cleanup;
-      }
-    } else if (strcmp(argv[i], "--exclude-from") == 0 && i + 1 < argc) {
-      if (read_patterns_from_file(argv[++i], &config->exclude_patterns, &config->exclude_count) !=
-          0) {
-        exit_code = 1;
-        goto cleanup;
-      }
-    } else if (strcmp(argv[i], "--include-from") == 0 && i + 1 < argc) {
-      if (read_patterns_from_file(argv[++i], &config->include_patterns, &config->include_count) !=
-          0) {
-        exit_code = 1;
-        goto cleanup;
-      }
     } else if (strcmp(argv[i], "-v") == 0 || strcmp(argv[i], "--verbose") == 0) {
       set_log_level(LOG_LEVEL_DEBUG);
     } else if (argv[i][0] == '-') {
       fprintf(stderr, "Unknown option: %s\n", argv[i]);
       print_usage();
-      exit_code = 1;
+      return 1;
-      goto cleanup;
     } else {
       if (positional_count < 2)
         positional_args[positional_count++] = i;
       else {
         fprintf(stderr, "Unexpected argument: %s\n", argv[i]);
         print_usage();
-        exit_code = 1;
+        return 1;
-        goto cleanup;
       }
     }
   }
@@ -331,8 +218,7 @@ int main(int argc, char* argv[]) {
   } else if (positional_count == 1) {
     fprintf(stderr, "Error: missing destination argument\n");
     print_usage();
-    exit_code = 1;
+    return 1;
-    goto cleanup;
   } else {
     if (!config->send_directory && env_source)
       config->send_directory = str_dup((char*)env_source);
@@ -343,26 +229,22 @@ int main(int argc, char* argv[]) {
   if (!config->send_directory || !config->receive_root_directory) {
     fprintf(stderr, "Error: source and destination directories are required\n");
     print_usage();
-    exit_code = 1;
+    return 1;
-    goto cleanup;
   }
   if (config->use_sendfile && (config->use_chunk_serialization || config->use_compression)) {
     fprintf(stderr, "Error: -f/--sendfile cannot be combined with -c (compression) or -s (chunk "
                     "serialization)\n");
-    exit_code = 1;
+    return 1;
-    goto cleanup;
   }
 
   if (config->transport == TRANSPORT_SSH && config->use_sendfile) {
     fprintf(stderr, "Error: -f/--sendfile is not supported with SSH transport\n");
-    exit_code = 1;
+    return 1;
-    goto cleanup;
   }
 
   if (config->use_incremental && config->use_chunk_serialization) {
     fprintf(stderr, "Error: --incremental is not supported with -s (chunk serialization)\n");
-    exit_code = 1;
+    return 1;
-    goto cleanup;
   }
 
   if (config->use_incremental && !config->use_metadata) {
@@ -372,18 +254,15 @@ int main(int argc, char* argv[]) {
 
   if (config->use_delta && !config->use_incremental) {
     fprintf(stderr, "Error: --delta requires --incremental\n");
-    exit_code = 1;
+    return 1;
-    goto cleanup;
   }
   if (config->use_delta && config->use_chunk_serialization) {
     fprintf(stderr, "Error: --delta cannot be combined with -s (chunk serialization)\n");
-    exit_code = 1;
+    return 1;
-    goto cleanup;
   }
   if (config->use_delta && config->use_sendfile) {
     fprintf(stderr, "Error: --delta cannot be combined with -f (sendfile)\n");
-    exit_code = 1;
+    return 1;
-    goto cleanup;
   }
   if (config->use_delta && !config->use_metadata) {
     log_message(LOG_LEVEL_INFO, "Enabling metadata preservation for --delta");
@@ -393,25 +272,12 @@ int main(int argc, char* argv[]) {
   if (config->use_tls) {
     if (!config->tls_cert || !config->tls_key) {
       fprintf(stderr, "Error: --tls requires --cert and --key\n");
-      exit_code = 1;
+      return 1;
-      goto cleanup;
     }
     tls_global_init();
   }
 
-  tcp_set_timeouts(config->timeout, config->contimeout);
+  if (config->use_multithreading)
-
+    return send_files_multithreaded(config);
-  if (config->use_multithreading) {
+  return send_files(config);
-    config_owned_by_pipeline = true;
-    exit_code = send_files_multithreaded(config);
-  } else {
-    exit_code = send_files(config);
-  }
-
-cleanup:
-  if (config->log_file)
-    fclose(config->log_file);
-  if (!config_owned_by_pipeline)
-    config_delete(config);
-  return exit_code;
 }

src/client/client_send.c

@@ -16,23 +16,12 @@
 #include "transport_ssh.h"
 #include "transport_tls.h"
 #include "utils.h"
-#include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <threads.h>
 #include <time.h>
 
-static volatile sig_atomic_t g_abort_requested = 0;
-static int g_abort_fd = -1;
-
-static void handle_sigint(int sig) {
-  (void)sig;
-  g_abort_requested = 1;
-}
-
-#define KEEPALIVE_INTERVAL 30
-
 static int incremental_check(Client* client, File* file, DeltaSignature** out_sig) {
   *out_sig = NULL;
   if (!send_status(client->file_descriptor, STATUS_CHECK))
@@ -107,98 +96,9 @@ static int send_delta(Client* client, File* file, DeltaSignature* sig, Config* c
   return ok ? 0 : -1;
 }
 
-static bool batch_incremental_check(Client* client, ArrayList* files) {
-  if (!send_status(client->file_descriptor, STATUS_CHECK_BATCH))
-    return false;
-  if (!send_int(client->file_descriptor, files->size))
-    return false;
-  for (int i = 0; i < files->size; i++) {
-    File* file = (File*)files->items[i];
-    if (!send_str(client->file_descriptor, file->path))
-      return false;
-    unsigned long long fsize = file->data ? file->data->size : 0;
-    long long mtime = file->metadata ? file->metadata->mtime_sec : 0;
-    if (!send_n_data(client->file_descriptor, &fsize, sizeof(fsize)))
-      return false;
-    if (!send_n_data(client->file_descriptor, &mtime, sizeof(mtime)))
-      return false;
-  }
-  for (int i = 0; i < files->size; i++) {
-    Status s;
-    if (!receive_status(client->file_descriptor, &s))
-      return false;
-    File* file = (File*)files->items[i];
-    if (s == STATUS_OK)
-      file->skip = true;
-    else if (s == STATUS_ERROR)
-      return false;
-  }
-  return true;
-}
-
 typedef bool (*file_send_fn)(File*, int, bool, int, bool);
 
-// Send a single file directly (non-incremental path).
+static int send_file_incremental(Client* client, File* file, Config* config, file_send_fn send_fn) {
-static bool send_file_direct(File* file, int fd, bool use_metadata, int compression_level) {
-  if (!send_status(fd, STATUS_NEXT))
-    return false;
-  return file_send_single_calls(file, fd, use_metadata, compression_level, true);
-}
-
-// Send a single file directly via sendfile (non-incremental path).
-static bool send_file_direct_sendfile(File* file, int fd, bool use_metadata) {
-  if (!send_status(fd, STATUS_NEXT))
-    return false;
-  return file_send_sendfile(file, fd, use_metadata, 0, true);
-}
-
-// Process one file in a chunk: either via incremental check or direct send.
-// Returns 0 on success, 1 if skipped (incremental match), -1 on error.
-static int send_single_file(Client* client, File* file, Config* config, bool use_incremental,
-                            bool use_sendfile) {
-  int compression_level = config->use_compression ? config->compression_level : 0;
-
-  if (file->skip)
-    return 1;
-
-  if (!use_incremental) {
-    if (use_sendfile) {
-      return send_file_direct_sendfile(file, client->file_descriptor, config->use_metadata) ? 0
-                                                                                            : -1;
-    }
-    return send_file_direct(file, client->file_descriptor, config->use_metadata, compression_level)
-               ? 0
-               : -1;
-  }
-
-  // Incremental path: use sendfile for the actual data if enabled and no compression
-  if (use_sendfile) {
-    DeltaSignature* sig = NULL;
-    int rc = incremental_check(client, file, &sig);
-    if (rc == 1) {
-      delta_signature_destroy(sig);
-      return 1;
-    }
-    if (rc < 0) {
-      delta_signature_destroy(sig);
-      return -1;
-    }
-    // rc == 0: unchanged file, skip
-    // rc == 2: server sent delta signature but sendfile doesn't support delta
-    delta_signature_destroy(sig);
-    if (rc == 2) {
-      // Server is waiting for STATUS_NEXT after delta handshake
-      if (!send_status(client->file_descriptor, STATUS_NEXT))
-        return -1;
-    }
-    // Fall through: send full file via sendfile (pass 0 for compression_level)
-    if (!file_send_sendfile(file, client->file_descriptor, config->use_metadata, 0, false))
-      return -1;
-    return 0;
-  }
-
-  // Incremental path with single_calls (supports compression and delta)
-  file_send_fn send_fn = (file_send_fn)file_send_single_calls;
   DeltaSignature* sig = NULL;
   int rc = incremental_check(client, file, &sig);
   if (rc < 0) {
@@ -218,15 +118,9 @@ static int send_single_file(Client* client, File* file, Config* config, bool use
       return -1;
   } else {
     delta_signature_destroy(sig);
-    // rc == 2 can happen if server sends STATUS_DELTA_SIGNATURE but
-    // use_delta is false on the client side. Send STATUS_NEXT to
-    // tell the server to proceed with the full file transfer.
-    if (rc == 2) {
-      if (!send_status(client->file_descriptor, STATUS_NEXT))
-        return -1;
-    }
   }
-  if (!send_fn(file, client->file_descriptor, config->use_metadata, compression_level, false))
+  if (!send_fn(file, client->file_descriptor, config->use_metadata,
+               config->use_compression ? config->compression_level : 0, false))
     return -1;
   return 0;
 }
@@ -248,17 +142,40 @@ int send_chunk(Client* client, Chunk* chunk, Config* config) {
       return -1;
     }
     data_destroy(data);
-    return 0;
+  } else if (config->use_sendfile && !config->use_compression) {
-  }
+    for (int i = 0; i < chunk->element_count; i++) {
-
+      if (config->use_incremental) {
-  bool use_sendfile = config->use_sendfile && !config->use_compression;
+        int rc = send_file_incremental(client, chunk->items[i], config,
-  for (int i = 0; i < chunk->element_count; i++) {
+                                       (file_send_fn)file_send_sendfile);
-    int rc =
+        if (rc == 1)
-        send_single_file(client, chunk->items[i], config, config->use_incremental, use_sendfile);
+          continue;
-    if (rc == 1)
+        if (rc < 0)
-      continue;
+          return -1;
-    if (rc < 0)
+      } else {
-      return -1;
+        if (!send_status(client->file_descriptor, STATUS_NEXT))
+          return -1;
+        if (!file_send_sendfile(chunk->items[i], client->file_descriptor, config->use_metadata, 0,
+                                true))
+          return -1;
+      }
+    }
+  } else {
+    for (int i = 0; i < chunk->element_count; i++) {
+      if (config->use_incremental) {
+        int rc = send_file_incremental(client, chunk->items[i], config,
+                                       (file_send_fn)file_send_single_calls);
+        if (rc == 1)
+          continue;
+        if (rc < 0)
+          return -1;
+      } else {
+        if (!send_status(client->file_descriptor, STATUS_NEXT))
+          return -1;
+        if (!file_send_single_calls(chunk->items[i], client->file_descriptor, config->use_metadata,
+                                    config->use_compression ? config->compression_level : 0, true))
+          return -1;
+      }
+    }
   }
   return 0;
 }
@@ -274,8 +191,7 @@ static int send_chunks_multithreaded(void* pipeline_context) {
     client = client_connect_ssh(context->config->ssh_destination, context->config->ssh_port);
   } else if (context->config->use_tls) {
     client = client_create();
-    if (!client || !client_connect_tls(client, context->config->server_host,
+    if (!client || !client_connect_tls(client, server_host, server_port, context->config->tls_cert,
-                                       context->config->server_port, context->config->tls_cert,
                                        context->config->tls_key, context->config->tls_ca)) {
       if (client)
         client_delete(client);
@@ -284,8 +200,7 @@ static int send_chunks_multithreaded(void* pipeline_context) {
     }
   } else {
     client = client_create();
-    if (!client ||
+    if (!client || !client_connect(client, server_host, server_port)) {
-        !client_connect(client, context->config->server_host, context->config->server_port)) {
       if (client)
         client_delete(client);
       fprintf(stderr, "Error: could not connect to server\n");
@@ -298,56 +213,23 @@ static int send_chunks_multithreaded(void* pipeline_context) {
     return thrd_error;
   }
 
-  g_abort_fd = client->file_descriptor;
-  time_t last_activity = time(NULL);
   while (true) {
-    if (g_abort_requested) {
-      send_status(client->file_descriptor, STATUS_ABORT);
-      client_disconnect(client);
-      client_delete(client);
-      return thrd_error;
-    }
-    time_t now = time(NULL);
-    if (now - last_activity >= KEEPALIVE_INTERVAL) {
-      if (!send_status(client->file_descriptor, STATUS_KEEPALIVE)) {
-        client_disconnect(client);
-        client_delete(client);
-        return thrd_error;
-      }
-      Status s;
-      if (!receive_status(client->file_descriptor, &s)) {
-        client_disconnect(client);
-        client_delete(client);
-        return thrd_error;
-      }
-      last_activity = now;
-    }
     Chunk* current_chunk = queue_dequeue_multithreaded(
         context->queue_loader, &context->mutex_loader, &context->condition_not_empty_loader,
         &context->condition_not_full_loader, &context->loader_done);
     if (current_chunk == NULL) {
       if (context->config->use_delete) {
-        if (!send_status(client->file_descriptor, STATUS_MANIFEST))
+        send_status(client->file_descriptor, STATUS_MANIFEST);
-          goto send_fail;
+        send_int(client->file_descriptor, context->manifest->size);
-        if (!send_int(client->file_descriptor, context->manifest->size))
+        for (int i = 0; i < context->manifest->size; i++)
-          goto send_fail;
+          send_str(client->file_descriptor, (char*)context->manifest->items[i]);
-        for (int i = 0; i < context->manifest->size; i++) {
-          if (!send_str(client->file_descriptor, (char*)context->manifest->items[i]))
-            goto send_fail;
-        }
       }
-      if (!send_status(client->file_descriptor, STATUS_FINISHED))
+      send_status(client->file_descriptor, STATUS_FINISHED);
-        goto send_fail;
       Status s;
       int ok = receive_status(client->file_descriptor, &s) && s == STATUS_OK;
       client_disconnect(client);
       client_delete(client);
       return ok ? thrd_success : thrd_error;
-
-    send_fail:
-      client_disconnect(client);
-      client_delete(client);
-      return thrd_error;
     }
     if (send_chunk(client, current_chunk, context->config) != 0) {
       fprintf(stderr, "Error: unexpected error while sending chunk\n");
@@ -366,7 +248,7 @@ static int scan_directory_multithreaded(void* pipeline_context) {
       context->config->send_directory, context->config->use_metadata, context->config->chunk_size,
       context->config->exclude_patterns, context->config->exclude_count,
       context->config->include_patterns, context->config->include_count, context->config->max_size,
-      context->config->min_size, context->config->max_depth);
+      context->config->min_size);
   mtx_unlock(&context->mutex_scanner);
 
   Chunk* current_chunk;
@@ -427,24 +309,21 @@ int send_files(Config* config) {
     DirectoryScanner* scanner = directory_scanner_create(
         config->send_directory, config->use_metadata, config->chunk_size, config->exclude_patterns,
         config->exclude_count, config->include_patterns, config->include_count, config->max_size,
-        config->min_size, config->max_depth);
+        config->min_size);
     Chunk* chunk;
     int file_count = 0;
     unsigned long long total_bytes = 0;
-    if (!config->quiet)
+    printf("Dry run: files to be transferred\n");
-      printf("Dry run: files to be transferred\n");
     while ((chunk = directory_scanner_next(scanner)) != NULL) {
       for (int i = 0; i < chunk->element_count; i++) {
-        if (!config->quiet)
+        printf("  %s (%zu bytes)\n", chunk->items[i]->path, chunk->items[i]->data->size);
-          printf("  %s (%zu bytes)\n", chunk->items[i]->path, chunk->items[i]->data->size);
         total_bytes += chunk->items[i]->data->size;
         file_count++;
       }
       chunk_destroy(chunk);
     }
     directory_scanner_destroy(scanner);
-    if (!config->quiet)
+    printf("Total: %d files, %.1f MB\n", file_count, total_bytes / 1048576.0);
-      printf("Total: %d files, %.1f MB\n", file_count, total_bytes / 1048576.0);
     return 0;
   }
 
@@ -459,8 +338,8 @@ int send_files(Config* config) {
       return 1;
   } else if (config->use_tls) {
     client = client_create();
-    if (!client || !client_connect_tls(client, config->server_host, config->server_port,
+    if (!client || !client_connect_tls(client, server_host, server_port, config->tls_cert,
-                                       config->tls_cert, config->tls_key, config->tls_ca)) {
+                                       config->tls_key, config->tls_ca)) {
       if (client)
         client_delete(client);
       fprintf(stderr, "Error: could not connect to server via TLS\n");
@@ -468,7 +347,7 @@ int send_files(Config* config) {
     }
   } else {
     client = client_create();
-    if (!client || !client_connect(client, config->server_host, config->server_port)) {
+    if (!client || !client_connect(client, server_host, server_port)) {
       if (client)
         client_delete(client);
       fprintf(stderr, "Error: could not connect to server\n");
@@ -480,98 +359,42 @@ int send_files(Config* config) {
     client_delete(client);
     return 1;
   }
-
-  g_abort_fd = client->file_descriptor;
-  struct sigaction sa;
-  memset(&sa, 0, sizeof(sa));
-  sa.sa_handler = handle_sigint;
-  sigaction(SIGINT, &sa, NULL);
-  sigaction(SIGTERM, &sa, NULL);
-
   DirectoryScanner* scanner = directory_scanner_create(
       config->send_directory, config->use_metadata, config->chunk_size, config->exclude_patterns,
       config->exclude_count, config->include_patterns, config->include_count, config->max_size,
-      config->min_size, config->max_depth);
+      config->min_size);
-  ArrayList* all_files = array_list_create(NULL);
-  ArrayList* manifest = config->use_delete ? array_list_create(free) : NULL;
   Chunk* current_chunk;
+  unsigned long long total_bytes = 0;
+  time_t last_progress = 0;
+  time_t start = time(NULL);
+  ArrayList* manifest = config->use_delete ? array_list_create(free) : NULL;
   while ((current_chunk = directory_scanner_next(scanner)) != NULL) {
+    unsigned long long chunk_bytes = 0;
     for (int i = 0; i < current_chunk->element_count; i++) {
-      File* f = current_chunk->items[i];
+      chunk_bytes += current_chunk->items[i]->data->size;
-      array_list_add(all_files, f);
-      current_chunk->items[i] = NULL;
       if (manifest) {
-        const char* p = f->path;
+        const char* p = current_chunk->items[i]->path;
         if (*p == '/')
           p++;
         array_list_add(manifest, str_dup(p));
       }
     }
-    chunk_destroy(current_chunk);
+    if (!config->use_sendfile) {
-  }
+      for (int i = 0; i < current_chunk->element_count; i++) {
-  directory_scanner_destroy(scanner);
+        if (!file_load_data(current_chunk->items[i])) {
-  scanner = NULL;
+          log_message(LOG_LEVEL_ERROR, "Failed to load file data");
-
+          continue;
-  bool batch_ok = true;
+        }
-  if (config->use_incremental && all_files->size > 0) {
+      }
-    if (!batch_incremental_check(client, all_files)) {
-      log_message(LOG_LEVEL_ERROR, "Batch incremental check failed");
-      batch_ok = false;
     }
-  }
+    if (send_chunk(client, current_chunk, config) != 0) {
-
+      log_message(LOG_LEVEL_ERROR, "Failed to send chunk");
-  unsigned long long total_bytes = 0;
+      chunk_destroy(current_chunk);
-  time_t last_progress = 0;
-  time_t last_activity = 0;
-  time_t start = time(NULL);
-  bool use_sendfile = config->use_sendfile && !config->use_compression;
-  for (int i = 0; i < all_files->size; i++) {
-    File* file = (File*)all_files->items[i];
-    if (file->skip)
-      continue;
-    if (g_abort_requested) {
-      send_status(client->file_descriptor, STATUS_ABORT);
-      batch_ok = false;
       break;
     }
-    time_t now = time(NULL);
-    if (now - last_activity >= KEEPALIVE_INTERVAL) {
-      if (!send_status(client->file_descriptor, STATUS_KEEPALIVE)) {
-        batch_ok = false;
-        break;
-      }
-      Status s;
-      if (!receive_status(client->file_descriptor, &s)) {
-        batch_ok = false;
-        break;
-      }
-      last_activity = now;
-    }
-    int compression_level = config->use_compression ? config->compression_level : 0;
-    if (!send_status(client->file_descriptor, STATUS_NEXT)) {
-      batch_ok = false;
-      break;
-    }
-    if (use_sendfile) {
-      if (!file_send_sendfile(file, client->file_descriptor, config->use_metadata, 0, true)) {
-        log_message(LOG_LEVEL_ERROR, "Failed to send file via sendfile");
-        batch_ok = false;
-        break;
-      }
-    } else {
-      if (!file_load_data(file)) {
-        log_message(LOG_LEVEL_ERROR, "Failed to load file data");
-        continue;
-      }
-      if (!file_send_single_calls(file, client->file_descriptor, config->use_metadata,
-                                  compression_level, true)) {
-        log_message(LOG_LEVEL_ERROR, "Failed to send file");
-        batch_ok = false;
-        break;
-      }
-    }
-    total_bytes += file->data ? file->data->size : 0;
     if (config->show_progress) {
+      total_bytes += chunk_bytes;
+      time_t now = time(NULL);
       if (now - last_progress >= 1) {
         last_progress = now;
         double elapsed = difftime(now, start);
@@ -580,71 +403,54 @@ int send_files(Config* config) {
         fflush(stderr);
       }
     }
+    chunk_destroy(current_chunk);
   }
-
+  if (config->use_delete) {
-  if (batch_ok && config->use_delete && manifest) {
+    send_status(client->file_descriptor, STATUS_MANIFEST);
-    if (!send_status(client->file_descriptor, STATUS_MANIFEST))
+    send_int(client->file_descriptor, manifest->size);
-      batch_ok = false;
+    for (int i = 0; i < manifest->size; i++)
-    else if (!send_int(client->file_descriptor, manifest->size))
+      send_str(client->file_descriptor, (char*)manifest->items[i]);
-      batch_ok = false;
+    array_list_delete(manifest);
-    else {
-      for (int i = 0; i < manifest->size && batch_ok; i++) {
-        if (!send_str(client->file_descriptor, (char*)manifest->items[i]))
-          batch_ok = false;
-      }
-    }
   }
-  array_list_delete(manifest);
+  send_status(client->file_descriptor, STATUS_FINISHED);
-
-  if (batch_ok && !send_status(client->file_descriptor, STATUS_FINISHED))
-    batch_ok = false;
   Status s;
-  int ok = 0;
+  int ok = receive_status(client->file_descriptor, &s) && s == STATUS_OK;
-  if (batch_ok)
-    ok = receive_status(client->file_descriptor, &s) && s == STATUS_OK;
   if (config->show_progress) {
     double elapsed = difftime(time(NULL), start);
     double rate = elapsed > 0 ? total_bytes / (1048576.0 * elapsed) : 0;
     fprintf(stderr, "\rSent %.1f MB  (%.1f MB/s)  Done.\n", total_bytes / 1048576.0, rate);
   }
-  for (int i = 0; i < all_files->size; i++)
+  directory_scanner_destroy(scanner);
-    file_destroy(all_files->items[i]);
-  array_list_delete(all_files);
   client_disconnect(client);
   client_delete(client);
-  return (batch_ok && ok) ? 0 : -1;
+  return ok ? 0 : -1;
 }
 
 int send_files_multithreaded(Config* config) {
-  time_t start_time = time(NULL);
   if (config->dry_run) {
     DirectoryScanner* scanner = directory_scanner_create(
         config->send_directory, config->use_metadata, config->chunk_size, config->exclude_patterns,
         config->exclude_count, config->include_patterns, config->include_count, config->max_size,
-        config->min_size, config->max_depth);
+        config->min_size);
     Chunk* chunk;
     int file_count = 0;
     unsigned long long total_bytes = 0;
-    if (!config->quiet)
+    printf("Dry run: files to be transferred\n");
-      printf("Dry run: files to be transferred\n");
     while ((chunk = directory_scanner_next(scanner)) != NULL) {
       for (int i = 0; i < chunk->element_count; i++) {
-        if (!config->quiet)
+        printf("  %s (%zu bytes)\n", chunk->items[i]->path, chunk->items[i]->data->size);
-          printf("  %s (%zu bytes)\n", chunk->items[i]->path, chunk->items[i]->data->size);
         total_bytes += chunk->items[i]->data->size;
         file_count++;
       }
       chunk_destroy(chunk);
     }
     directory_scanner_destroy(scanner);
-    if (!config->quiet)
+    printf("Total: %d files, %.1f MB\n", file_count, total_bytes / 1048576.0);
-      printf("Total: %d files, %.1f MB\n", file_count, total_bytes / 1048576.0);
     return 0;
   }
 
-  int qsize = config->queue_size > 0 ? config->queue_size : 100;
+  Queue* q1 = queue_create(100, chunk_destroy);
-  Queue* q1 = queue_create(qsize, chunk_destroy);
+  Queue* q2 = queue_create(100, chunk_destroy);
-  Queue* q2 = queue_create(qsize, chunk_destroy);
   if (!q1 || !q2) {
     if (q1)
       queue_destroy(q1);
@@ -675,12 +481,6 @@ int send_files_multithreaded(Config* config) {
   thrd_join(loader, NULL);
   thrd_join(sender, &sender_result);
 
-  if (config->stats && !config->quiet) {
-    double elapsed = difftime(time(NULL), start_time);
-    printf("\nTransfer statistics:\n");
-    printf("  Elapsed time: %.1f sec\n", elapsed);
-  }
-
   pipeline_context_sender_destroy(context);
   return sender_result == thrd_success ? 0 : -1;
 }

src/client/client_send.h

@@ -5,6 +5,9 @@
 #include "config.h"
 #include "transport_tcp.h"
 
+extern char* server_host;
+extern int server_port;
+
 int send_chunk(Client* client, Chunk* chunk, Config* config);
 int send_files(Config* config);
 int send_files_multithreaded(Config* config);

src/client/scanner.c

@@ -11,37 +11,15 @@
 #include <sys/stat.h>
 #include <unistd.h>
 
-typedef struct {
+DirectoryScanner* directory_scanner_create(char* root_directory, bool use_metadata,
-  char* path;
-  int depth;
-} DirEntry;
-
-static void dir_entry_destroy(void* item) {
-  if (item) {
-    DirEntry* de = (DirEntry*)item;
-    free(de->path);
-    free(de);
-  }
-}
-
-static DirEntry* dir_entry_create(const char* path, int depth) {
-  DirEntry* de = malloc(sizeof(DirEntry));
-  if (de) {
-    de->path = str_dup(path);
-    de->depth = depth;
-  }
-  return de;
-}
-
-DirectoryScanner* directory_scanner_create(const char* root_directory, bool use_metadata,
                                            unsigned long long chunk_size, char** exclude_patterns,
                                            int exclude_count, char** include_patterns,
                                            int include_count, unsigned long long max_size,
-                                           unsigned long long min_size, int max_depth) {
+                                           unsigned long long min_size) {
   DirectoryScanner* scanner = malloc(sizeof(DirectoryScanner));
   if (scanner == NULL)
     return NULL;
-  scanner->directories = queue_create(100, dir_entry_destroy);
+  scanner->directories = queue_create(100, free);
   scanner->current_dir = NULL;
   scanner->current_path = NULL;
   scanner->use_metadata = use_metadata;
@@ -52,9 +30,7 @@ DirectoryScanner* directory_scanner_create(const char* root_directory, bool use_
   scanner->include_count = include_count;
   scanner->max_size = max_size;
   scanner->min_size = min_size;
-  scanner->max_depth = max_depth;
+  queue_enqueue(scanner->directories, str_dup(root_directory));
-  scanner->current_depth = 0;
-  queue_enqueue(scanner->directories, dir_entry_create(root_directory, 0));
   return scanner;
 }
 
@@ -79,7 +55,6 @@ static Chunk* chunk_data_to_chunk(ArrayList* chunk_data) {
   return chunk;
 }
 
-// Returns: 1 on success, 0 if no more directories in queue, -1 on opendir failure
 static int open_next_directory(DirectoryScanner* scanner) {
   if (scanner->current_dir) {
     closedir(scanner->current_dir);
@@ -90,16 +65,13 @@ static int open_next_directory(DirectoryScanner* scanner) {
   if (queue_is_empty(scanner->directories))
     return 0;
 
-  DirEntry* de = (DirEntry*)queue_dequeue(scanner->directories);
+  scanner->current_path = (char*)queue_dequeue(scanner->directories);
-  scanner->current_path = de->path;
-  scanner->current_depth = de->depth;
-  free(de);
   scanner->current_dir = opendir(scanner->current_path);
   if (scanner->current_dir == NULL) {
     perror("Could not open directory");
     free(scanner->current_path);
     scanner->current_path = NULL;
-    return -1;
+    return 0;
   }
   return 1;
 }
@@ -110,11 +82,8 @@ Chunk* directory_scanner_next(DirectoryScanner* scanner) {
 
   while (1) {
     if (scanner->current_dir == NULL) {
-      int ret = open_next_directory(scanner);
+      if (!open_next_directory(scanner))
-      if (ret == 0)
         break;
-      if (ret < 0)
-        continue;
     }
 
     struct dirent* entry = readdir(scanner->current_dir);
@@ -137,16 +106,8 @@ Chunk* directory_scanner_next(DirectoryScanner* scanner) {
     }
 
     if (S_ISDIR(stats.st_mode)) {
-      int next_depth = scanner->current_depth + 1;
+      queue_enqueue(scanner->directories, (void*)cur_path);
-      if (scanner->max_depth <= 0 || next_depth < scanner->max_depth)
-        queue_enqueue(scanner->directories, dir_entry_create(cur_path, next_depth));
-      else
-        free(cur_path);
     } else {
-      if (scanner->max_depth > 0 && scanner->current_depth + 1 > scanner->max_depth) {
-        free(cur_path);
-        continue;
-      }
       bool excluded = false;
       for (int i = 0; i < scanner->exclude_count; i++) {
         if (glob_match(scanner->exclude_patterns[i], entry->d_name)) {

src/client/scanner.h

@@ -18,15 +18,13 @@ typedef struct {
   int include_count;
   unsigned long long max_size;
   unsigned long long min_size;
-  int max_depth;
-  int current_depth;
 } DirectoryScanner;
 
-DirectoryScanner* directory_scanner_create(const char* root_directory, bool use_metadata,
+DirectoryScanner* directory_scanner_create(char* root_directory, bool use_metadata,
                                            unsigned long long chunk_size, char** exclude_patterns,
                                            int exclude_count, char** include_patterns,
                                            int include_count, unsigned long long max_size,
-                                           unsigned long long min_size, int max_depth);
+                                           unsigned long long min_size);
 Chunk* directory_scanner_next(DirectoryScanner* scanner);
 void directory_scanner_destroy(DirectoryScanner* scanner);
 

src/server/server.c

@@ -21,16 +21,7 @@ int receive_files(Config* config, int fd) {
   if (!receive_status(fd, &status))
     return -1;
 
-  while (status == STATUS_NEXT || status == STATUS_CHUNK || status == STATUS_CHECK ||
+  while (status == STATUS_NEXT || status == STATUS_CHUNK || status == STATUS_CHECK) {
-         status == STATUS_KEEPALIVE || status == STATUS_ABORT || status == STATUS_CHECK_BATCH) {
-    if (status == STATUS_KEEPALIVE) {
-      send_status(fd, STATUS_KEEPALIVE);
-      goto next;
-    }
-    if (status == STATUS_ABORT) {
-      log_message(LOG_LEVEL_INFO, "Received abort from client, cleaning up");
-      return -1;
-    }
     if (status == STATUS_CHECK) {
       bool skipped;
       File* file = receive_incremental_check(fd, config, &skipped);
@@ -39,7 +30,7 @@ int receive_files(Config* config, int fd) {
       if (file == NULL && !skipped)
         return -1;
       if (config->save_to_disk)
-        file_save_to_disk(config->receive_root_directory, file, NULL);
+        file_save_to_disk(config->receive_root_directory, file);
       file_destroy(file);
     } else if (status == STATUS_CHUNK) {
       Chunk* chunk = receive_chunk_data(fd, config);
@@ -49,37 +40,9 @@ int receive_files(Config* config, int fd) {
       }
       for (int i = 0; i < chunk->element_count; i++) {
         if (config->save_to_disk)
-          file_save_to_disk(config->receive_root_directory, chunk->items[i], NULL);
+          file_save_to_disk(config->receive_root_directory, chunk->items[i]);
       }
       chunk_destroy(chunk);
-    } else if (status == STATUS_CHECK_BATCH) {
-      int count;
-      if (!receive_int(fd, &count))
-        return -1;
-      for (int i = 0; i < count; i++) {
-        char* check_path = receive_str(fd);
-        if (!check_path)
-          return -1;
-        unsigned long long check_size;
-        long long check_mtime;
-        if (!receive_n_data(fd, &check_size, sizeof(check_size)) ||
-            !receive_n_data(fd, &check_mtime, sizeof(check_mtime))) {
-          free(check_path);
-          return -1;
-        }
-        char* full_path = path_cat(config->receive_root_directory, check_path);
-        struct stat st;
-        bool has_old = full_path && stat(full_path, &st) == 0;
-        bool match = has_old && (unsigned long long)st.st_size == check_size &&
-                     (long long)st.st_mtime == check_mtime;
-        if (match)
-          send_status(fd, STATUS_OK);
-        else
-          send_status(fd, STATUS_NEXT);
-        free(full_path);
-        free(check_path);
-      }
-      goto next;
     } else {
       File* file = file_receive(config, fd);
       if (file == NULL) {
@@ -88,7 +51,7 @@ int receive_files(Config* config, int fd) {
         return -1;
       }
       if (config->save_to_disk)
-        file_save_to_disk(config->receive_root_directory, file, NULL);
+        file_save_to_disk(config->receive_root_directory, file);
       file_destroy(file);
     }
   next:

src/shared/compression.c

@@ -7,6 +7,7 @@
 #define INITIAL_DECOMPRESS_BUF_SIZE (1024 * 1024)
 
 Data* data_compress(Data* data_to_compress, int compression_level) {
+  (void)compression_level;
   log_message(LOG_LEVEL_DEBUG, "Starting to compress data");
   size_t dst_size = ZSTD_compressBound(data_to_compress->size);
   Data* compressed_data = data_create_empty(dst_size);
@@ -20,14 +21,6 @@ Data* data_compress(Data* data_to_compress, int compression_level) {
     return NULL;
   }
 
-  size_t zret = ZSTD_CCtx_setParameter(cctx, ZSTD_c_compressionLevel, compression_level);
-  if (ZSTD_isError(zret)) {
-    log_message(LOG_LEVEL_ERROR, "Failed to set compression level: %s", ZSTD_getErrorName(zret));
-    ZSTD_freeCCtx(cctx);
-    data_destroy(compressed_data);
-    return NULL;
-  }
-
   ZSTD_inBuffer input = {data_to_compress->data, data_to_compress->size, 0};
   ZSTD_outBuffer output = {compressed_data->data, dst_size, 0};
 

src/shared/config.c

@@ -45,17 +45,6 @@ Config* config_create(char* version, char* send_directory, char* receive_directo
   config->tls_cert = NULL;
   config->tls_key = NULL;
   config->tls_ca = NULL;
-  config->server_host = str_dup("127.0.0.1");
-  config->server_port = 8080;
-  config->timeout = 30;
-  config->contimeout = 10;
-  config->quiet = false;
-  config->backup = false;
-  config->backup_dir = NULL;
-  config->stats = false;
-  config->max_depth = 0;
-  config->log_file = NULL;
-  config->queue_size = 100;
   return config;
 }
 
@@ -99,8 +88,6 @@ void config_delete(Config* config) {
   free(config->tls_cert);
   free(config->tls_key);
   free(config->tls_ca);
-  free(config->backup_dir);
-  free(config->server_host);
   free(config);
 }
 
@@ -123,7 +110,7 @@ bool config_send(int file_descriptor, const Config* config) {
     return false;
   if (!send_int(file_descriptor, config->compression_level))
     return false;
-  if (!send_n_data(file_descriptor, &config->chunk_size, sizeof(config->chunk_size)))
+  if (!send_int(file_descriptor, (int)config->chunk_size))
     return false;
   if (!send_int(file_descriptor, config->use_sendfile))
     return false;
@@ -137,10 +124,6 @@ bool config_send(int file_descriptor, const Config* config) {
     return false;
   if (!send_n_data(file_descriptor, &config->delta_max_file_size, sizeof(unsigned long long)))
     return false;
-  if (!send_int(file_descriptor, config->backup))
-    return false;
-  if (!send_str(file_descriptor, config->backup_dir ? config->backup_dir : ""))
-    return false;
   Status status;
   if (!receive_status(file_descriptor, &status))
     return false;
@@ -155,7 +138,6 @@ Config* config_receive(int file_descriptor) {
   Config* config = (Config*)malloc(sizeof(Config));
   if (config == NULL)
     return NULL;
-  memset(config, 0, sizeof(*config));
   config->version = receive_str(file_descriptor);
   if (!config->version) {
     free(config);
@@ -201,8 +183,9 @@ Config* config_receive(int file_descriptor) {
   if (!receive_int(file_descriptor, &tmp))
     goto error;
   config->compression_level = tmp;
-  if (!receive_n_data(file_descriptor, &config->chunk_size, sizeof(config->chunk_size)))
+  if (!receive_int(file_descriptor, &tmp))
     goto error;
+  config->chunk_size = (unsigned long long)tmp;
   if (!receive_int(file_descriptor, &tmp))
     goto error;
   config->use_sendfile = tmp;
@@ -235,21 +218,6 @@ Config* config_receive(int file_descriptor) {
   config->tls_cert = NULL;
   config->tls_key = NULL;
   config->tls_ca = NULL;
-  config->timeout = 30;
-  config->contimeout = 10;
-  config->quiet = false;
-  config->stats = false;
-  config->max_depth = 0;
-  config->log_file = NULL;
-  config->queue_size = 100;
-  if (!receive_int(file_descriptor, &tmp))
-    goto error;
-  config->backup = tmp;
-  config->backup_dir = receive_str(file_descriptor);
-  if (config->backup_dir == NULL)
-    goto error;
-  config->server_host = str_dup("127.0.0.1");
-  config->server_port = 8080;
   if (!send_status(file_descriptor, STATUS_OK))
     goto error;
   return config;
@@ -258,7 +226,6 @@ error:
   free(config->version);
   free(config->send_directory);
   free(config->receive_root_directory);
-  free(config->server_host);
   free(config);
   return NULL;
 }

src/shared/config.h

@@ -3,7 +3,6 @@
 
 #include <stdbool.h>
 #include <stdint.h>
-#include <stdio.h>
 
 typedef enum { TRANSPORT_TCP, TRANSPORT_SSH } TransportType;
 
@@ -36,23 +35,12 @@ typedef struct Config {
   uint32_t delta_block_size;
   unsigned long long delta_max_file_size;
   bool use_tls;
-  char* server_host;
-  int server_port;
   char* tls_cert;
   char* tls_key;
   char* tls_ca;
-  int timeout;
-  int contimeout;
-  bool quiet;
-  bool backup;
-  char* backup_dir;
-  bool stats;
-  int max_depth;
-  FILE* log_file;
-  int queue_size;
 } Config;
 
-#define PROTOCOL_VERSION "1.3.0"
+#define PROTOCOL_VERSION "1.2.0"
 #define DEFAULT_CHUNK_SIZE (10 * 1024 * 1024)
 
 Config* config_create(char* version, char* send_directory, char* receive_directory,

src/shared/delta.c

@@ -108,12 +108,7 @@ DeltaSignature* delta_signature_deserialize(const Data* data) {
     return NULL;
   }
 
-  uint64_t blocks_size = (uint64_t)sig->block_count * sizeof(DeltaBlockSig);
+  sig->blocks = malloc(sig->block_count * sizeof(DeltaBlockSig));
-  if (blocks_size > SIZE_MAX) {
-    free(sig);
-    return NULL;
-  }
-  sig->blocks = malloc((size_t)blocks_size);
   if (!sig->blocks) {
     free(sig);
     return NULL;

src/shared/file.c

@@ -1,5 +1,4 @@
 #include <dirent.h>
-#include <errno.h>
 #include <fcntl.h>
 #include <libgen.h>
 #include <stddef.h>
@@ -43,7 +42,6 @@ File* file_create(const char* path) {
     return NULL;
   }
   file->metadata = NULL;
-  file->skip = false;
   return file;
 }
 
@@ -128,12 +126,7 @@ bool file_send_single_calls(File* file, int file_descriptor, bool use_metadata,
   return true;
 }
 
-bool file_save_to_disk(const char* root_directory, File* file, const Config* config) {
+bool file_save_to_disk(const char* root_directory, File* file) {
-  (void)config;
-  if (has_path_traversal(file->path)) {
-    log_message(LOG_LEVEL_ERROR, "Path traversal detected in file path: %s", file->path);
-    return false;
-  }
   char* disk_path = path_cat((char*)root_directory, file->path);
   if (disk_path == NULL)
     return false;
@@ -332,13 +325,6 @@ File* receive_incremental_check(int fd, const Config* config, bool* skipped) {
     return NULL;
   }
 
-  if (has_path_traversal(check_path)) {
-    log_message(LOG_LEVEL_ERROR, "Path traversal detected: %s", check_path);
-    free(check_path);
-    send_status(fd, STATUS_ERROR);
-    return NULL;
-  }
-
   char* full_path = path_cat(config->receive_root_directory, check_path);
   struct stat st;
   bool has_old_file = (full_path && stat(full_path, &st) == 0);
@@ -423,72 +409,33 @@ File* receive_incremental_check(int fd, const Config* config, bool* skipped) {
 }
 
 bool to_disk(const char* path, const void* data, unsigned long long data_size) {
-  char* tmp_path = NULL;
+  char* directory = str_dup(path);
-  char* directory = NULL;
+  char* dir_to_free = directory;
-
+  directory = dirname(directory);
-  char* path_dup = str_dup(path);
+  if (!mkdir_r(directory)) {
-  if (!path_dup)
+    free(dir_to_free);
     return false;
-  const char* dir_result = dirname(path_dup);
-  directory = str_dup(dir_result);
-  free(path_dup);
-  if (!directory)
-    return false;
-
-  bool ok = true;
-  if (!mkdir_r(directory))
-    goto done;
-
-  size_t path_len = strlen(path);
-  tmp_path = malloc(path_len + 5);
-  if (!tmp_path) {
-    ok = false;
-    goto done;
   }
-  memcpy(tmp_path, path, path_len);
+  FILE* file_pointer = fopen(path, "wb");
-  memcpy(tmp_path + path_len, ".tmp", 5);
-
-  FILE* file_pointer = fopen(tmp_path, "wb");
   if (file_pointer == NULL) {
-    perror("Could not open temporary file");
+    perror("Could not open File");
-    ok = false;
+    free(dir_to_free);
-    goto done;
+    return false;
   }
   if (fwrite(data, 1, data_size, file_pointer) != data_size) {
-    perror("Failed to write all data to temporary file");
+    perror("Failed to write all data to disk");
     fclose(file_pointer);
-    unlink(tmp_path);
+    free(dir_to_free);
-    ok = false;
+    return false;
-    goto done;
   }
   fclose(file_pointer);
-
+  free(dir_to_free);
-  if (rename(tmp_path, path) != 0) {
+  return true;
-    perror("Failed to atomically rename temporary file");
-    unlink(tmp_path);
-    ok = false;
-    goto done;
-  }
-
-done:
-  free(tmp_path);
-  free(directory);
-  return ok;
 }
 
 bool file_send_sendfile(File* file, int file_descriptor, bool use_metadata, int compression_level,
                         bool send_path) {
-  // sendfile is incompatible with compression (kernel zero-copy).
+  (void)compression_level;
-  // If compression is requested, fall back to the regular send path.
-  // NOTE: This is a safety net only — callers must ensure compression_level == 0
-  // before calling file_send_sendfile. The fallback to file_send_single_calls
-  // preserves the send_path contract, but callers should not rely on it for
-  // correctness (the --sendfile flag is validated to be mutually exclusive with
-  // -c/--compress at the CLI layer).
-  if (compression_level > 0)
-    return file_send_single_calls(file, file_descriptor, use_metadata, compression_level,
-                                  send_path);
-
   if (send_path && !send_str(file_descriptor, file->path))
     return false;
   if (use_metadata && !metadata_send(file_descriptor, file->metadata))

src/shared/file.h

@@ -18,7 +18,6 @@ typedef struct {
   char* path;
   Data* data;
   FileMetadata* metadata;
-  bool skip;
 } File;
 
 File* file_create(const char* path);
@@ -33,7 +32,7 @@ size_t file_content_to_buffer(File* file);
 FileMetadata* file_metadata_create(const struct stat* stats);
 void file_metadata_destroy(void* metadata);
 bool to_disk(const char* path, const void* data, unsigned long long data_size);
-bool file_save_to_disk(const char* root_directory, File* file, const Config* config);
+bool file_save_to_disk(const char* root_directory, File* file);
 File* receive_incremental_check(int fd, const Config* config, bool* skipped);
 int receive_manifest(int fd, const Config* config, int* next_status);
 

src/shared/log.c

@@ -5,16 +5,11 @@
 
 static const char* log_level_strings[] = {"DEBUG", "INFO", "WARN", "ERROR"};
 static LogLevel current_log_level = LOG_LEVEL_WARNING;
-static FILE* log_fp = NULL;
 
 void set_log_level(LogLevel level) {
   current_log_level = level;
 }
 
-void log_set_file(FILE* fp) {
-  log_fp = fp;
-}
-
 void log_message(LogLevel log_level, char* format, ...) {
   if (log_level < current_log_level)
     return;
@@ -29,14 +24,4 @@ void log_message(LogLevel log_level, char* format, ...) {
   vfprintf(stderr, format, args);
   va_end(args);
   fprintf(stderr, "\n");
-
-  if (log_fp) {
-    fprintf(log_fp, "%04d-%02d-%02d %02d:%02d:%02d [%s]: ", t->tm_year + 1900, t->tm_mon + 1,
-            t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, log_level_strings[log_level]);
-    va_start(args, format);
-    vfprintf(log_fp, format, args);
-    va_end(args);
-    fprintf(log_fp, "\n");
-    fflush(log_fp);
-  }
 }

src/shared/log.h

@@ -1,12 +1,9 @@
 #ifndef LOG_H
 #define LOG_H
 
-#include <stdio.h>
-
 typedef enum { LOG_LEVEL_DEBUG, LOG_LEVEL_INFO, LOG_LEVEL_WARNING, LOG_LEVEL_ERROR } LogLevel;
 
 void log_message(LogLevel log_level, char* message, ...);
 void set_log_level(LogLevel level);
-void log_set_file(FILE* fp);
 
 #endif

src/shared/metadata.c

@@ -1,8 +1,6 @@
 #include "metadata.h"
 #include "file.h"
-#include "log.h"
 #include "protocol.h"
-#include <errno.h>
 #include <fcntl.h>
 #include <stdlib.h>
 #include <string.h>
@@ -98,15 +96,13 @@ FileMetadata* metadata_receive(int file_descriptor, int* ok) {
 void file_restore_metadata(const char* path, FileMetadata* metadata) {
   if (metadata == NULL)
     return;
-  if (chmod(path, metadata->mode & 07777) != 0)
+  chmod(path, metadata->mode & 07777);
-    log_message(LOG_LEVEL_WARNING, "Failed to chmod %s: %s", path, strerror(errno));
+  int chown_ret = chown(path, metadata->uid, metadata->gid);
-  if (chown(path, metadata->uid, metadata->gid) != 0)
+  (void)chown_ret;
-    log_message(LOG_LEVEL_WARNING, "Failed to chown %s: %s", path, strerror(errno));
   struct timespec times[2];
   times[0].tv_sec = 0;
   times[0].tv_nsec = UTIME_OMIT;
   times[1].tv_sec = metadata->mtime_sec;
   times[1].tv_nsec = metadata->mtime_nsec;
-  if (utimensat(AT_FDCWD, path, times, 0) != 0)
+  utimensat(AT_FDCWD, path, times, 0);
-    log_message(LOG_LEVEL_WARNING, "Failed to set timestamps on %s: %s", path, strerror(errno));
 }

src/shared/multiprocessing.c

@@ -105,16 +105,7 @@ int receive_thread(void* pipeline_context) {
   Status status;
   if (!receive_status(file_descriptor, &status))
     return thrd_error;
-  while (status == STATUS_NEXT || status == STATUS_CHUNK || status == STATUS_CHECK ||
+  while (status == STATUS_NEXT || status == STATUS_CHUNK || status == STATUS_CHECK) {
-         status == STATUS_KEEPALIVE || status == STATUS_ABORT || status == STATUS_CHECK_BATCH) {
-    if (status == STATUS_KEEPALIVE) {
-      send_status(file_descriptor, STATUS_KEEPALIVE);
-      goto next;
-    }
-    if (status == STATUS_ABORT) {
-      log_message(LOG_LEVEL_INFO, "Received abort from client, cleaning up");
-      return thrd_error;
-    }
     if (status == STATUS_CHECK) {
       bool skipped;
       File* file = receive_incremental_check(file_descriptor, config, &skipped);
@@ -126,34 +117,6 @@ int receive_thread(void* pipeline_context) {
       }
     } else if (status == STATUS_CHUNK) {
       receive_chunk_enqueue(file_descriptor, context);
-    } else if (status == STATUS_CHECK_BATCH) {
-      int count;
-      if (!receive_int(file_descriptor, &count))
-        return thrd_error;
-      for (int i = 0; i < count; i++) {
-        char* check_path = receive_str(file_descriptor);
-        if (!check_path)
-          return thrd_error;
-        unsigned long long check_size;
-        long long check_mtime;
-        if (!receive_n_data(file_descriptor, &check_size, sizeof(check_size)) ||
-            !receive_n_data(file_descriptor, &check_mtime, sizeof(check_mtime))) {
-          free(check_path);
-          return thrd_error;
-        }
-        char* full_path = path_cat(config->receive_root_directory, check_path);
-        struct stat st;
-        bool has_old = full_path && stat(full_path, &st) == 0;
-        bool match = has_old && (unsigned long long)st.st_size == check_size &&
-                     (long long)st.st_mtime == check_mtime;
-        if (match)
-          send_status(file_descriptor, STATUS_OK);
-        else
-          send_status(file_descriptor, STATUS_NEXT);
-        free(full_path);
-        free(check_path);
-      }
-      goto next;
     } else {
       File* file = file_receive(config, file_descriptor);
       if (file) {
@@ -163,7 +126,6 @@ int receive_thread(void* pipeline_context) {
         log_message(LOG_LEVEL_ERROR, "Failed to receive file");
       }
     }
-  next:
     if (!receive_status(file_descriptor, &status))
       return thrd_error;
   }
@@ -194,7 +156,7 @@ int write_thread(void* pipeline_context) {
       return thrd_success;
     }
     if (save_to_disk)
-      file_save_to_disk(root_directory, file, context->config);
+      file_save_to_disk(root_directory, file);
     file_destroy(file);
   }
 }

src/shared/protocol.c

@@ -8,10 +8,6 @@
 #include <time.h>
 #include <unistd.h>
 
-#define MAX_DATA_SIZE (256ULL * 1024 * 1024)          /* 256 MB max per message */
-#define RECEIVE_TIMEOUT_SEC 60                        /* 60 second per-message timeout */
-#define MAX_CONNECTION_MEMORY (1024ULL * 1024 * 1024) /* 1 GB total per connection */
-
 static __thread int io_read_fd = -1;
 static __thread int io_write_fd = -1;
 static SSL* io_ssl = NULL;
@@ -20,8 +16,6 @@ static unsigned long long io_bwlimit = 0;
 static long long bw_tokens = 0;
 static struct timespec bw_last_refill = {0, 0};
 
-static __thread unsigned long long total_allocated_bytes = 0;
-
 void io_set_fds(int read_fd, int write_fd) {
   io_read_fd = read_fd;
   io_write_fd = write_fd;
@@ -98,21 +92,8 @@ bool send_n_data(int file_descriptor, const void* data, size_t data_size) {
 bool receive_n_data(int file_descriptor, void* data, size_t data_size) {
   log_message(LOG_LEVEL_DEBUG, "    Receiving n Data: %zu", data_size);
   int fd = io_fd(io_read_fd, file_descriptor);
-
-  struct timespec deadline;
-  clock_gettime(CLOCK_MONOTONIC, &deadline);
-  deadline.tv_sec += RECEIVE_TIMEOUT_SEC;
-
   size_t total_bytes_received = 0;
   while (total_bytes_received < data_size) {
-    struct timespec now;
-    clock_gettime(CLOCK_MONOTONIC, &now);
-    if (now.tv_sec > deadline.tv_sec ||
-        (now.tv_sec == deadline.tv_sec && now.tv_nsec > deadline.tv_nsec)) {
-      log_message(LOG_LEVEL_ERROR, "Receive timeout after %ds", RECEIVE_TIMEOUT_SEC);
-      return false;
-    }
-
     ssize_t bytes_received;
     if (io_ssl)
       bytes_received =
@@ -151,12 +132,6 @@ static const char* status_to_string(Status status) {
     return "DELTA_SIGNATURE";
   case STATUS_DELTA_DATA:
     return "DELTA_DATA";
-  case STATUS_KEEPALIVE:
-    return "KEEPALIVE";
-  case STATUS_ABORT:
-    return "ABORT";
-  case STATUS_CHECK_BATCH:
-    return "CHECK_BATCH";
   default:
     return "UNKNOWN";
   }
@@ -176,11 +151,6 @@ char* receive_str(int file_descriptor) {
   size_t size;
   if (!receive_n_data(file_descriptor, &size, sizeof(size_t)))
     return NULL;
-  if (size > MAX_DATA_SIZE) {
-    log_message(LOG_LEVEL_ERROR, "String size %zu exceeds maximum %llu", size,
-                (unsigned long long)MAX_DATA_SIZE);
-    return NULL;
-  }
   char* data = (char*)malloc(size + 1);
   if (data == NULL)
     return NULL;
@@ -207,17 +177,6 @@ Data* receive_data(int file_descriptor) {
   unsigned long long size = 0;
   if (!receive_n_data(file_descriptor, &size, sizeof(unsigned long long)))
     return NULL;
-  if (size > MAX_DATA_SIZE) {
-    log_message(LOG_LEVEL_ERROR, "Data size %llu exceeds maximum %llu", size,
-                (unsigned long long)MAX_DATA_SIZE);
-    return NULL;
-  }
-  if (total_allocated_bytes + size > MAX_CONNECTION_MEMORY) {
-    log_message(LOG_LEVEL_ERROR, "Per-connection memory limit exceeded (%llu + %llu > %llu)",
-                (unsigned long long)total_allocated_bytes, size,
-                (unsigned long long)MAX_CONNECTION_MEMORY);
-    return NULL;
-  }
   void* data = malloc((size_t)size);
   if (data == NULL)
     return NULL;
@@ -225,7 +184,6 @@ Data* receive_data(int file_descriptor) {
     free(data);
     return NULL;
   }
-  total_allocated_bytes += size;
   log_message(LOG_LEVEL_DEBUG, "Received %lld data", size);
   return data_create(data, (size_t)size);
 }

src/shared/protocol.h

@@ -17,10 +17,7 @@ enum NET_STATUS {
   STATUS_MANIFEST,
   STATUS_CHECK,
   STATUS_DELTA_SIGNATURE,
-  STATUS_DELTA_DATA,
+  STATUS_DELTA_DATA
-  STATUS_KEEPALIVE,
-  STATUS_ABORT,
-  STATUS_CHECK_BATCH
 };
 
 void io_set_fds(int read_fd, int write_fd);

src/shared/transport_ssh.c

@@ -1,5 +1,4 @@
 #include "transport_ssh.h"
-#include "utils.h"
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -9,58 +8,39 @@
 #include <unistd.h>
 
 typedef struct {
-  char* user;
+  char user[256];
-  char* host;
+  char host[256];
-  char* remote_path;
+  char remote_path[4096];
 } RemoteDest;
 
-static void remote_dest_destroy(RemoteDest* r) {
-  free(r->user);
-  free(r->host);
-  free(r->remote_path);
-}
-
 static int parse_remote_dest(const char* dest, RemoteDest* r) {
-  memset(r, 0, sizeof(*r));
   const char* colon = strchr(dest, ':');
   if (!colon)
     return -1;
 
-  r->remote_path = str_dup(colon + 1);
+  size_t remote_path_len = strlen(colon + 1);
-  if (!r->remote_path)
+  if (remote_path_len >= sizeof(r->remote_path))
     return -1;
+  memcpy(r->remote_path, colon + 1, remote_path_len + 1);
 
   const char* at = memchr(dest, '@', colon - dest);
   if (at) {
     size_t user_len = at - dest;
-    r->user = malloc(user_len + 1);
+    if (user_len >= sizeof(r->user))
-    if (!r->user) {
-      remote_dest_destroy(r);
       return -1;
-    }
     memcpy(r->user, dest, user_len);
     r->user[user_len] = '\0';
 
     size_t host_len = colon - at - 1;
-    r->host = malloc(host_len + 1);
+    if (host_len >= sizeof(r->host))
-    if (!r->host) {
-      remote_dest_destroy(r);
       return -1;
-    }
     memcpy(r->host, at + 1, host_len);
     r->host[host_len] = '\0';
   } else {
-    r->user = str_dup("");
+    r->user[0] = '\0';
-    if (!r->user) {
-      remote_dest_destroy(r);
-      return -1;
-    }
     size_t host_len = colon - dest;
-    r->host = malloc(host_len + 1);
+    if (host_len >= sizeof(r->host))
-    if (!r->host) {
-      remote_dest_destroy(r);
       return -1;
-    }
     memcpy(r->host, dest, host_len);
     r->host[host_len] = '\0';
   }
@@ -77,7 +57,6 @@ Client* client_connect_ssh(const char* destination, int port) {
   int sv[2];
   if (socketpair(AF_UNIX, SOCK_STREAM, 0, sv) < 0) {
     perror("socketpair failed");
-    remote_dest_destroy(&r);
     return NULL;
   }
 
@@ -92,7 +71,6 @@ Client* client_connect_ssh(const char* destination, int port) {
     perror("pipe failed");
     close(sv[0]);
     close(sv[1]);
-    remote_dest_destroy(&r);
     return NULL;
   }
 
@@ -103,7 +81,6 @@ Client* client_connect_ssh(const char* destination, int port) {
     close(sv[1]);
     close(exec_pipe[0]);
     close(exec_pipe[1]);
-    remote_dest_destroy(&r);
     return NULL;
   }
 
@@ -111,6 +88,7 @@ Client* client_connect_ssh(const char* destination, int port) {
     close(sv[0]);
     close(exec_pipe[0]);
     fcntl(exec_pipe[1], F_SETFD, FD_CLOEXEC);
+
     if (sv[1] != STDIN_FILENO)
       dup2(sv[1], STDIN_FILENO);
     if (sv[1] != STDOUT_FILENO)
@@ -118,18 +96,11 @@ Client* client_connect_ssh(const char* destination, int port) {
     if (sv[1] > 1)
       close(sv[1]);
 
-    size_t ssh_user_len;
+    char ssh_user[512];
-    if (r.user && r.user[0] != '\0')
+    if (r.user[0] != '\0')
-      ssh_user_len = strlen(r.user) + 1 + strlen(r.host) + 1;
+      snprintf(ssh_user, sizeof(ssh_user), "%s@%s", r.user, r.host);
     else
-      ssh_user_len = strlen(r.host) + 1;
+      snprintf(ssh_user, sizeof(ssh_user), "%s", r.host);
-    char* ssh_user = malloc(ssh_user_len);
-    if (!ssh_user)
-      _exit(1);
-    if (r.user && r.user[0] != '\0')
-      snprintf(ssh_user, ssh_user_len, "%s@%s", r.user, r.host);
-    else
-      snprintf(ssh_user, ssh_user_len, "%s", r.host);
 
     char* ssh_argv[16];
     int ac = 0;
@@ -167,13 +138,10 @@ Client* client_connect_ssh(const char* destination, int port) {
   if (n > 0) {
     close(sv[0]);
     waitpid(pid, NULL, 0);
-    remote_dest_destroy(&r);
     fprintf(stderr, "Error: could not launch 'fastsync-server --stdio' on remote\n");
     return NULL;
   }
 
-  remote_dest_destroy(&r);
-
   Client* client = malloc(sizeof(Client));
   if (client == NULL) {
     close(sv[0]);

src/shared/transport_tcp.c

@@ -2,7 +2,6 @@
 #include "log.h"
 #include "protocol.h"
 #include <arpa/inet.h>
-#include <errno.h>
 #include <openssl/ssl.h>
 #include <signal.h>
 #include <stdio.h>
@@ -12,18 +11,6 @@
 #include <sys/wait.h>
 #include <unistd.h>
 
-static volatile unsigned int g_active_connections = 0;
-
-static void sigchld_handler(int sig) {
-  (void)sig;
-  int saved_errno = errno;
-  while (waitpid(-1, NULL, WNOHANG) > 0) {
-    if (g_active_connections > 0)
-      g_active_connections--;
-  }
-  errno = saved_errno;
-}
-
 Server* server_create(int port) {
   Server* server = (Server*)malloc(sizeof(Server));
   if (server == NULL) {
@@ -51,8 +38,6 @@ Server* server_create(int port) {
   server->address.sin_port = htons(port);
   server->address_length = sizeof(server->address);
   server->ssl_ctx = NULL;
-  server->max_connections = 100;
-  server->active_connections = 0;
 
   if (bind(server->file_descriptor, (struct sockaddr*)&server->address, server->address_length) <
       0) {
@@ -83,7 +68,7 @@ static void accept_loop(Server* server, void (*child_fn)(int, void*), void* chil
     perror("Could not listen on port!");
     return;
   }
-  signal(SIGCHLD, sigchld_handler);
+  signal(SIGCHLD, SIG_IGN);
   while (1) {
     struct sockaddr_in client_addr;
     socklen_t client_len = sizeof(client_addr);
@@ -92,12 +77,6 @@ static void accept_loop(Server* server, void (*child_fn)(int, void*), void* chil
       perror("Could not accept the connection");
       continue;
     }
-    if (g_active_connections >= server->max_connections) {
-      log_message(LOG_LEVEL_WARNING, "Max connections (%u) reached, rejecting",
-                  server->max_connections);
-      close(fd);
-      continue;
-    }
     log_message(LOG_LEVEL_INFO, "%s", log_fmt);
     pid_t pid = fork();
     if (pid == 0) {
@@ -105,8 +84,6 @@ static void accept_loop(Server* server, void (*child_fn)(int, void*), void* chil
       child_fn(fd, child_ctx);
       close(fd);
       _exit(0);
-    } else if (pid > 0) {
-      g_active_connections++;
     }
     close(fd);
   }
@@ -133,24 +110,6 @@ void server_accept_loop(Server* server, void (*child_fn)(int, void*), void* chil
   accept_loop(server, child_fn, child_ctx, log_fmt);
 }
 
-static int g_timeout_sec = 30;
-static int g_contimeout_sec = 10;
-
-void tcp_set_timeouts(int timeout_sec, int contimeout_sec) {
-  if (timeout_sec > 0)
-    g_timeout_sec = timeout_sec;
-  if (contimeout_sec > 0)
-    g_contimeout_sec = contimeout_sec;
-}
-
-static void tcp_apply_socket_timeout(int fd) {
-  struct timeval tv;
-  tv.tv_sec = g_timeout_sec;
-  tv.tv_usec = 0;
-  setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
-  setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
-}
-
 Client* client_create() {
   int file_descriptor = socket(AF_INET, SOCK_STREAM, 0);
   if (file_descriptor < 0) {
@@ -174,27 +133,17 @@ Client* client_create() {
 
 bool client_connect(Client* client, char* host, int port) {
   client->address.sin_port = htons(port);
-  client->address.sin_family = AF_INET;
-  client->address_length = sizeof(client->address);
 
   if (inet_pton(AF_INET, host, &client->address.sin_addr) <= 0) {
     perror("Could not convert host address!");
     return false;
   }
 
-  struct timeval ct;
-  ct.tv_sec = g_contimeout_sec;
-  ct.tv_usec = 0;
-  setsockopt(client->file_descriptor, SOL_SOCKET, SO_RCVTIMEO, &ct, sizeof(ct));
-  setsockopt(client->file_descriptor, SOL_SOCKET, SO_SNDTIMEO, &ct, sizeof(ct));
-
   if (connect(client->file_descriptor, (struct sockaddr*)&client->address, client->address_length) <
       0) {
     perror("Could not connect to Server!");
     return false;
   }
-
-  tcp_apply_socket_timeout(client->file_descriptor);
   return true;
 }
 

src/shared/transport_tcp.h

@@ -10,8 +10,6 @@ typedef struct Server {
   unsigned int address_length;
   int file_descriptor;
   void* ssl_ctx;
-  unsigned int max_connections;
-  volatile unsigned int active_connections;
 } Server;
 
 typedef struct Client {
@@ -32,6 +30,5 @@ Client* client_create();
 bool client_connect(Client* client, char* host, int port);
 void client_disconnect(Client* client);
 void client_delete(Client* client);
-void tcp_set_timeouts(int timeout_sec, int contimeout_sec);
 
 #endif

src/shared/transport_tls.c

@@ -72,8 +72,6 @@ static SSL_CTX* create_ssl_ctx(bool is_server, const char* cert, const char* key
     }
     SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, NULL);
     SSL_CTX_set_verify_depth(ctx, 4);
-  } else {
-    SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, NULL);
   }
 
   return ctx;

src/shared/utils.c

@@ -2,7 +2,6 @@
 #include "array_list.h"
 #include "libgen.h"
 #include <dirent.h>
-#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -27,8 +26,7 @@ bool mkdir_r(const char* path) {
     path_current[0] = '\0';
   }
   const char* delimiter = "/";
-  char* saveptr;
+  const char* part = strtok(path_duplicate, delimiter);
-  const char* part = strtok_r(path_duplicate, delimiter, &saveptr);
   bool ok = true;
   while (part != NULL) {
     strcpy(path_current_position, part);
@@ -43,7 +41,7 @@ bool mkdir_r(const char* path) {
         break;
       }
     }
-    part = strtok_r(NULL, delimiter, &saveptr);
+    part = strtok(NULL, delimiter);
   }
   free(path_duplicate);
   free(path_current);
@@ -83,22 +81,10 @@ bool glob_match(const char* pattern, const char* str) {
   return *str == '\0';
 }
 
-static bool is_dir_in_manifest(const char* rel_path, ArrayList* manifest) {
-  size_t len = strlen(rel_path);
-  for (int i = 0; i < manifest->size; i++) {
-    const char* entry = (const char*)manifest->items[i];
-    // Check if entry starts with rel_path + '/' or matches exactly
-    if (strncmp(entry, rel_path, len) == 0 && (entry[len] == '/' || entry[len] == '\0'))
-      return true;
-  }
-  return false;
-}
-
 static void delete_extras_walk(const char* abs_path, const char* rel_path, ArrayList* manifest) {
   DIR* dir = opendir(abs_path);
   if (!dir)
     return;
-  bool all_removed = true;
   struct dirent* entry;
   while ((entry = readdir(dir)) != NULL) {
     if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
@@ -113,11 +99,6 @@ static void delete_extras_walk(const char* abs_path, const char* rel_path, Array
     }
     if (S_ISDIR(st.st_mode)) {
       delete_extras_walk(child_abs, child_rel, manifest);
-      // After recursion, try to remove the subdirectory if it's now empty.
-      // Ignore ENOENT: the recursive call may have already removed it.
-      if (rmdir(child_abs) != 0 && errno != ENOENT) {
-        all_removed = false;
-      }
     } else {
       // Check if relative path is in manifest
       bool found = false;
@@ -130,44 +111,19 @@ static void delete_extras_walk(const char* abs_path, const char* rel_path, Array
       if (!found) {
         unlink(child_abs);
         fprintf(stderr, "  Deleted: %s\n", child_rel);
-      } else {
-        all_removed = false;
       }
     }
     free(child_abs);
     free(child_rel);
   }
   closedir(dir);
-  // Only remove the directory itself if it is not in the manifest
+  rmdir(abs_path);
-  // and contained no kept entries.
-  if (all_removed && rel_path[0] != '\0' && !is_dir_in_manifest(rel_path, manifest)) {
-    rmdir(abs_path);
-  }
 }
 
 void delete_extras(const char* dest_root, ArrayList* manifest) {
   delete_extras_walk(dest_root, "", manifest);
 }
 
-bool has_path_traversal(const char* path) {
-  if (!path)
-    return false;
-  char* dup = str_dup(path);
-  if (!dup)
-    return false;
-  char* saveptr;
-  const char* part = strtok_r(dup, "/", &saveptr);
-  while (part) {
-    if (strcmp(part, "..") == 0) {
-      free(dup);
-      return true;
-    }
-    part = strtok_r(NULL, "/", &saveptr);
-  }
-  free(dup);
-  return false;
-}
-
 char* path_cat(const char* path1, char* path2) {
   if (path1 == NULL || *path1 == '\0')
     return str_dup(path2);

src/shared/utils.h

@@ -9,6 +9,5 @@ char* str_dup(const char* string);
 char* path_cat(const char* path1, char* path2);
 bool glob_match(const char* pattern, const char* str);
 void delete_extras(const char* dest_root, ArrayList* manifest);
-bool has_path_traversal(const char* path);
 
 #endif

tests/test_file.c

@@ -69,7 +69,7 @@ static void test_file_save_to_disk() {
   memcpy(f->data->data, content, strlen(content));
   f->data->size = strlen(content);
 
-  EXPECT_TRUE(file_save_to_disk("test_save_tmp", f, NULL));
+  EXPECT_TRUE(file_save_to_disk("test_save_tmp", f));
 
   struct stat st;
   EXPECT_EQ_INT(stat("test_save_tmp/saved_file.txt", &st), 0);

tests/test_scanner.c

@@ -19,7 +19,7 @@ static void test_scanner_single_file() {
   create_test_file(file1, content1);
 
   DirectoryScanner* scanner =
-      directory_scanner_create((char*)dir, false, 0, NULL, 0, NULL, 0, 0, 0, 0);
+      directory_scanner_create((char*)dir, false, 0, NULL, 0, NULL, 0, 0, 0);
   EXPECT_NOT_NULL(scanner);
 
   Chunk* chunk = directory_scanner_next(scanner);
@@ -48,7 +48,7 @@ static void test_scanner_multiple_files() {
   create_test_file(file2, content2);
 
   DirectoryScanner* scanner =
-      directory_scanner_create((char*)dir, false, 0, NULL, 0, NULL, 0, 0, 0, 0);
+      directory_scanner_create((char*)dir, false, 0, NULL, 0, NULL, 0, 0, 0);
   EXPECT_NOT_NULL(scanner);
 
   const Chunk* chunk = directory_scanner_next(scanner);
@@ -88,7 +88,7 @@ static void test_scanner_subdirectory() {
   create_test_file(sub_file, content);
 
   DirectoryScanner* scanner =
-      directory_scanner_create((char*)root, false, 0, NULL, 0, NULL, 0, 0, 0, 0);
+      directory_scanner_create((char*)root, false, 0, NULL, 0, NULL, 0, 0, 0);
   EXPECT_NOT_NULL(scanner);
 
   int total_files = 0;
@@ -112,7 +112,7 @@ static void test_scanner_empty_directory() {
   mkdir(dir, 0755);
 
   DirectoryScanner* scanner =
-      directory_scanner_create((char*)dir, false, 0, NULL, 0, NULL, 0, 0, 0, 0);
+      directory_scanner_create((char*)dir, false, 0, NULL, 0, NULL, 0, 0, 0);
   EXPECT_NOT_NULL(scanner);
 
   const Chunk* chunk = directory_scanner_next(scanner);