@antodevs/groundtruth 0.1.0

package/README.md

@@ -0,0 +1,130 @@
+![GroundTruth Banner](assets/banner.png)
+
+# GroundTruth
+
+> Zero-configuration context injection layer for LLM-based coding agents.
+
+![npm](https://img.shields.io/npm/v/groundtruth)
+![license](https://img.shields.io/npm/l/groundtruth)
+![node](https://img.shields.io/node/v/groundtruth)
+
+---
+
+## Architecture Overview
+
+Current-generation AI coding assistants (Claude Code, Antigravity, Cursor) suffer from deterministic knowledge cutoffs, rendering them ineffective when working with bleeding-edge frameworks (e.g., Svelte 5+, React 19). 
+
+**GroundTruth** acts as a transparent middleware layer that resolves this by dynamically injecting real-time, stack-specific documentation directly into the agent's context window prior to inference.
+
+---
+
+## Architecture & Operational Mechanics
+
+GroundTruth operates in two distinct execution modes depending on the target agent's architecture. 
+
+### 1. Proxy Intercept Mode (Designed for `claude-code`)
+
+In this mode, GroundTruth provisions a local HTTP proxy that intercepts outbound API calls targeting Anthropic's endpoints.
+
+```mermaid
+sequenceDiagram
+    participant Agent as Claude Code
+    participant Proxy as GroundTruth Proxy
+    participant Search as DuckDuckGo
+    participant API as Anthropic API
+
+    Agent->>Proxy: Send Prompt (POST /v1/messages)
+    Proxy->>Search: Extract stack/query & scrape live docs
+    Search-->>Proxy: Return real-time web context
+    Note over Proxy: Injects live context<br/>into System Prompt
+    Proxy->>API: Forward mutated request
+    API-->>Agent: Return completion with fresh knowledge
+```
+
+- **Query Extraction**: Parses the user prompt to identify context dependencies.
+- **Data Hydration**: Orchestrates an automated DuckDuckGo search to fetch the most recent documentation. It relies on a deterministic `LRUCache`, TCP keep-alive Pool configurations, and a 429-aware `CircuitBreaker` pattern to safeguard network operations safely.
+- **Payload Mutation**: Mutates the outgoing system prompt to inject the scraped live context before forwarding the request to the Anthropic completion endpoint. (It includes type-guard structures making it safe from undocumented Gemini system changes).
+
+### 2. File Watcher Mode (Designed for `antigravity` / `gemini`)
+
+For agents that support side-channel context ingestion via dotfiles (like Antigravity Rules), GroundTruth runs as a background daemon.
+
+```mermaid
+flowchart TD
+    pkg([package.json]) -->|Parse Dependencies| GT{GroundTruth Watcher}
+    GT -->|Search Stack Queries| DDG[(DuckDuckGo)]
+    DDG -->|Return Live Docs| GT
+    GT -->|Sync periodically| File[~/.gemini/GEMINI.md]
+    File -->|Auto-loaded| Agent(Antigravity Agent)
+    Agent -->|Execute| Prompt[Prompt with Fresh Context]
+
+    classDef core fill:#3B82F6,stroke:#fff,stroke-width:2px,color:#fff;
+    class GT,Agent core;
+```
+
+- **Stack Introspection**: Analyzes the local `package.json` to infer the project's dependency graph.
+- **Intelligent Chunking**: Groups the filtered dependencies in configurable size batches (default 3) and uniquely hashes them to avoid redundant context-fetching loops unless changes are detected.
+- **Automated Polling**: Periodically fetches updated documentation for the detected stack chunks in parallel.
+- **State Persistence**: Hashes are serialized persistently avoiding redundant DuckDuckGo scraping operations across application crashes.
+- **Block-Based Synchronization**: Writes the parsed context discretely into hash-oriented blocks inside `~/.gemini/GEMINI.md`. Native POSIX bindings are leveraged ensuring `Atomic Writes`. Stale contexts are efficiently garbage-collected via regex matching over tracked batch hashes.
+
+---
+
+## Installation & Usage
+
+### Usage with Claude Code
+```bash
+# Initialize GroundTruth in proxy mode (auto-exports ANTHROPIC_BASE_URL)
+npx groundtruth --claude-code
+
+# Execute your agent in a separate TTY
+claude
+```
+> **Note:** The daemon automatically mutates your shell environment (`~/.zshrc`, `~/.bashrc`, `config.fish`) to route traffic through the localhost proxy.
+
+### Usage with Antigravity / Gemini
+```bash
+cd /workspace/your-project
+
+# Initialize the daemon in file watcher mode
+npx groundtruth --antigravity
+```
+> **Note:** GroundTruth will continuously poll and sync documentation based on your `package.json` manifest.
+
+---
+
+## CLI Reference
+
+| Flag | Mode | Technical Description |
+|------|------|-------------|
+| `--claude-code` | Proxy | Initializes HTTP interceptor for Anthropic API payloads. |
+| `--antigravity` | Rules | Initializes background daemon for dotfile synchronization. |
+| `--use-package-json` | Both | Enforces AST/manifest parsing of `package.json` for query generation. |
+| `--port <n>` | Proxy | Overrides default proxy listener port (Default: `8080`). |
+| `--interval <n>` | Rules | Overrides the polling interval for documentation refresh in minutes (Default: `5`). |
+| `--batch-size <n>` | Rules | Changes the amount of dependencies per query chunk for block fetching (Default: `3`, Min: `2`, Max: `5`). |
+
+---
+
+## Benchmark & Comparison
+
+GroundTruth is heavily optimized for zero-configuration deployments and minimal token overhead compared to existing MCP (Model Context Protocol) solutions.
+
+| Feature | GroundTruth | Brave MCP | Playwright MCP | Firecrawl |
+|---------|-------------|-----------|----------------|-----------|
+| **Authentication** | None Required | API Key | None Required | API Key |
+| **Token Overhead** | ~500 tokens | ~800 tokens | ~13,000 tokens | ~800 tokens |
+| **Antigravity Support** | Native | Unsupported | Unsupported | Unsupported |
+| **Runtime Footprint** | < 1MB | < 1MB | ~200MB | < 1MB |
+| **Shell Auto-config** | Automated | Manual | Manual | Manual |
+
+---
+
+## System Requirements
+- Node.js runtime (v18.0.0 or higher)
+- Supported Agent (Antigravity or Claude Code)
+
+---
+
+## License
+MIT

package/index.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+/**
+ * @module index
+ * @description Entry point runtime groundtruth delegazione CLI o proxy flow logic.
+ */
+import { chalk, label } from './src/logger.js';
+import { usePackageJson, antigravityMode, claudeCodeMode, port, intervalMinutes, batchSize, version } from './src/cli.js';
+import { createServer } from './src/proxy.js';
+import { autoSetEnv } from './src/env.js';
+import { startWatcher } from './src/watcher.js';
+
+// ─── Dispatcher start app logic ──────────────────────
+
+if (antigravityMode) {
+  startWatcher({ intervalMinutes, usePackageJson, batchSize });
+} else if (claudeCodeMode) {
+  const server = await createServer(usePackageJson);
+  const startServer = (p) => {
+    // EADDRINUSE fallback listener fail chain ricorsivo su port shift param logic 
+    server.on('error', (e) => (e.code === 'EADDRINUSE' ? startServer(p + 1) : console.error(chalk.red(`Server error: ${e.message}`))));
+    server.listen(p, async () => {
+      console.log(`\n  ${chalk.white.bold('GroundTruth')}  ${chalk.gray(`v${version}`)}  ${chalk.gray('[claude-code mode]')}\n`);
+      console.log(label('◆', 'proxy', `localhost:${p}`));
+      console.log(label('◆', 'anthropic', '/v1/messages'));
+      console.log(label('◆', 'gemini', '/v1beta/…'));
+      console.log(label('◆', 'context', 'DuckDuckGo → live'));
+      console.log(`\n  ${chalk.cyan('✻')} Listening. Set ANTHROPIC_BASE_URL=http://localhost:${p}\n`);
+      await autoSetEnv(p);
+    });
+  };
+  startServer(port);
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@antodevs/groundtruth",
+  "version": "0.1.0",
+  "description": "Lightweight Node.js proxy to intercept API requests from coding agents and inject fresh web context",
+  "type": "module",
+  "license": "MIT",
+  "author": "Anto",
+  "keywords": [
+    "llm",
+    "context",
+    "ai",
+    "proxy",
+    "gemini",
+    "anthropic",
+    "claude",
+    "antigravity",
+    "coding-assistant"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/anto0102/GroundTruth.git"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "index.js",
+    "src/",
+    "assets/",
+    "specification.yaml",
+    "README.md",
+    "LICENSE"
+  ],
+  "bin": {
+    "groundtruth": "index.js"
+  },
+  "scripts": {
+    "start": "node index.js",
+    "dev": "node --watch index.js"
+  },
+  "dependencies": {
+    "@mozilla/readability": "^0.5.0",
+    "chalk": "^5.3.0",
+    "cheerio": "^1.0.0",
+    "linkedom": "^0.18.12",
+    "node-fetch": "^3.3.2"
+  }
+}

package/specification.yaml

@@ -0,0 +1,143 @@
+name: GroundTruth
+version: 0.1.0
+description: |
+  GroundTruth is a zero-configuration, transparent middleware context injection layer.
+  It is designed to bridge the deterministic knowledge cutoff gap of LLM-based coding agents 
+  (such as Claude Code or Antigravity) by dynamically fetching and injecting live, 
+  dependency-specific documentation right before inference or via out-of-band rule files.
+
+architecture:
+  modes:
+    - name: Proxy Intercept Mode
+      alias: claude-code
+      description: |
+        Operates as a local HTTP reverse-proxy interceptor that captures outgoing API payloads 
+        targeting Anthropic or Google Gemini endpoints, mutating them in transit.
+      target_endpoints:
+        - "https://api.anthropic.com/v1/messages"
+        - "https://generativelanguage.googleapis.com/v1beta/models/*"
+      flow:
+        1: "Listen on localhost port (default: 8080) and capture POST requests."
+        2: "Extract the last user message from the JSON body (supports `messages` array for Anthropic and `contents` array for Gemini)."
+        3: "Determine search query: use `--use-package-json` AST parsing, or fallback to the user message text."
+        4: "Scrape DuckDuckGo concurrently to retrieve live context (title, snippet, Readability-parsed text up to 4000 chars)."
+        5: "Mutate the `system` instruction prompt in the JSON payload by appending the live context block."
+        6: "Forward the modified request to the actual LLM provider, streaming the response back to the client."
+      components:
+        - src/proxy.js
+
+    - name: File Watcher Mode
+      alias: antigravity
+      description: |
+        Runs as a persistent background daemon. It polls the local project's dependencies, 
+        fetches up-to-date documentation, and generates synchronized knowledge base dotfiles 
+        (`GEMINI.md`) that the agent natively reads on invocation.
+      flow:
+        1: "Parses `package.json` dependencies and filters out build/tooling packages (e.g., eslint, vite, adapter)."
+        2: "Groups the filtered dependencies into chunks (batching) of configurable size (default: 3, max: 5) using `groupIntoBatches`."
+        3: "Hashes each dependency chunk (`batchHash` md5 sliced to 8 chars) to uniquely identify rule blocks and track state."
+        4: "Checks previous state to avoid redundant network fetches if the batch hasn't changed (`previousDepsKey` mapping)."
+        5: "Fetches live DuckDuckGo results per batch asynchronously, filtering out low-quality pages (403, captcha, < 200 chars)."
+        6: "Injects distinct dependency rule blocks bounded by `<!-- groundtruth:block-{hash}:start/end -->` directly inside `~/.gemini/GEMINI.md` (global) and `./.gemini/GEMINI.md` (workspace)."
+        7: "Garbage-collects stale blocks (`removeStaleBlocks`) belonging to evicted or resolved dependencies by regex matching active block IDs."
+      components:
+        - src/watcher.js
+        - src/inject.js
+
+core_modules:
+  - name: cli.js
+    responsibilities: 
+      - "Process `process.argv` argument parsing."
+      - "Validation and defaulting of arguments (`--port`, `--interval`, `--batch-size`)."
+      - "Help/Docs Screen rendering and early exit conditions."
+  
+  - name: search.js
+    responsibilities: 
+      - "DuckDuckGo HTML scraping using `cheerio`."
+      - "URL resolution from DuckDuckGo's `uddg` tracking links."
+      - "User-Agent rotation to mitigate scraping blocks."
+      - "Integration with `CircuitBreaker` pattern for rate-limit protection."
+      - "Integration with bounded custom O(1) `LRUCache` from `cache.js`."
+      - "Page content extraction using `linkedom` and Mozilla's `Readability`."
+      - "Integration with persistent connection pooling components from `http-agent.js`."
+  
+  - name: packages.js
+    responsibilities: 
+      - "Read local Node modules context (`package.json`)."
+      - "Clean semantic versions (e.g., `^1.2.3` -> `1.2`)."
+      - "Filter out non-informative tooling (`vite`, `prettier`, `eslint`)."
+      - "Group dependencies into manageable batches (`groupIntoBatches`)."
+      - "Generate deterministic MD5 identifiers per batch for block management (`batchHash`)."
+      - "Construct search queries based on dependency batches plus temporal identifiers (`latest 2026`)."
+  
+  - name: logger.js
+    responsibilities: 
+      - "Chalk-driven aesthetic terminal formatting."
+      - "Centralized status symbolizing constants (✓, ⚠, ⚡, ↻, ◆, ✻)."
+      - "Timestamp generation mapped to `it-IT` locale."
+  
+  - name: env.js
+    responsibilities: 
+      - "Shell configuration auto-instrumentation (`.zshrc`, `.bashrc`, `.bash_profile`, `config.fish`)."
+      - "Exporting `ANTHROPIC_BASE_URL` to route CLI tools (like Claude Code) through the proxy."
+      - "Cross-Platform Environment Override (Bypassing Windows systems safely)."
+  
+  - name: inject.js
+    responsibilities: 
+      - "File I/O operations for `GEMINI.md` in both `$HOME` and `$CWD`."
+      - "Regex-based block injection using exact start/end bounds matching."
+      - "Stale block eviction via `removeStaleBlocks`."
+      - "Uses `atomicWrite` for zero-corruption file replacements."
+
+  - name: cache.js
+    responsibilities:
+      - "Implements zero-dependency O(1) bounded LRU caching logic."
+      - "Provides getter/setter mechanisms tied to temporal eviction limits."
+
+  - name: circuit-breaker.js
+    responsibilities:
+      - "Manages DuckDuckGo fetch attempts via threshold-based error state wrapping (OPEN/HALF_OPEN/CLOSED)."
+
+  - name: state.js
+    responsibilities:
+      - "Persistent recovery system for dependency batch hashes mapping across system crash/restarts."
+      - "Reads and writes `.gemini/watcher-state.json`."
+
+  - name: http-agent.js
+    responsibilities:
+      - "Creates reusable Keep-Alive HTTP and HTTPS configuration agents to mitigate handshake overheads."
+
+  - name: utils/atomic-write.js
+    responsibilities:
+      - "Creates temporary file blocks performing `fs.rename` (POSIX) or falls back to standard `fs.copyFile` safe-copies (Windows)."
+
+dependencies:
+  runtime: "Node.js >= 18.0.0 (uses ES Modules)"
+  built_ins: 
+    - fs
+    - path
+    - os
+    - http
+    - https
+    - crypto
+  third_party:
+    - chalk: "^5.3.0" # Terminal styling
+    - cheerio: "^1.0.0" # Fast HTML parsing for DDG results
+    - linkedom: "^0.18.5" # Lightweight DOM emulation for Mozilla Readability
+    - node-fetch: "^3.3.2" # WHATWG Fetch API polyfill for Node
+    - "@mozilla/readability": "^0.5.0" # Main content extraction
+
+mechanics:
+  caching_and_eviction:
+    - "Search level caching: Runtime searches are cached for 5 minutes (`CACHE_TTL`), matching identical queries to avoid redundant network transit."
+    - "Watcher level caching: the daemon uses a Map tracking `blockId` -> `JSON.stringify(batch)`. If the hash signature matches across cycles, the network layer is skipped."
+  quality_assurance:
+    - "Content verification: Extracted text is sanitized and evaluated. If a page returns < 200 characters, or contains indicators of bot protection (e.g., '403', 'captcha', 'access denied'), the result is flagged."
+    - "Fallback mechanism: If a result is flagged as low-quality, the watcher rolls back and retains the successfully injected markdown block from the previous cycle."
+  network_resilience:
+    - "Timeouts: All outbound `node-fetch` requests strictly adhere to a 5-second `AbortSignal.timeout(5000)`."
+    - "Retries & Bans: `search.js` relies on a `CircuitBreaker` class mitigating recursive DuckDuckGo IP bans."
+    - "Resource Connection: Avoids TCP handshakes through persistent keep-alive Agent dispatching."
+  shell_integration:
+    - "Darwin/Linux-first: Windows OS (`win32`) skips autoconfig cleanly."
+    - "Fish Shell paths uniquely utilize `set -gx` constructs unlike standard Bash/Zsh `export` syntax, appending recursively or mutating existing assignments."

package/src/cache.js

@@ -0,0 +1,107 @@
+/**
+ * @module cache
+ * @description Implementazione zero-dep LRU Cache limitata memory bounds.
+ */
+
+/**
+ * @description Store memory con eviction LRU O(1) in get/set.
+ */
+class LRUCache {
+    /**
+     * @param {Object} options - Impostazioni max size e ttl ms
+     */
+    constructor(options = {}) {
+        this.max = options.max || 500;
+        this.ttl = options.ttl || 5 * 60 * 1000; // 5 min default TTL
+        this.cache = new Map();
+        // Doubly-linked list base structure per LRU policy cost O(1)
+        this.head = { key: null, next: null, prev: null };
+        this.tail = { key: null, next: null, prev: null };
+        this.head.next = this.tail;
+        this.tail.prev = this.head;
+        this.size = 0;
+    }
+
+    _remove(node) {
+        node.prev.next = node.next;
+        node.next.prev = node.prev;
+    }
+
+    _addToFront(node) {
+        node.next = this.head.next;
+        node.prev = this.head;
+        this.head.next.prev = node;
+        this.head.next = node;
+    }
+
+    /**
+     * @description Fetch nodo con eviction passiva su scadenza TTL.
+     * @param   {string} key - Chiave archivio identificativa
+     * @returns {any} Valore salvato o undefined su miss
+     */
+    get(key) {
+        const node = this.cache.get(key);
+        if (!node) return undefined;
+
+        // TTL lazy evict check se expiro
+        if (Date.now() > node.expiresAt) {
+            this.delete(key);
+            return undefined;
+        }
+
+        // Promote a recency target node
+        this._remove(node);
+        this._addToFront(node);
+        return node.value;
+    }
+
+    /**
+     * @description Assegna un nodo alla testa (recent).
+     * @param   {string} key   - Target key
+     * @param   {any}    value - Target val
+     * @returns {LRUCache} Istanza chaining
+     */
+    set(key, value) {
+        // Pulizia pre-insert per sovrascrittura o cap bounds
+        if (this.cache.has(key)) {
+            const old = this.cache.get(key);
+            this._remove(old);
+            this.cache.delete(key);
+            this.size--;
+        } else if (this.size >= this.max) {
+            const lru = this.tail.prev;
+            if (lru.key) {
+                this._remove(lru);
+                this.cache.delete(lru.key);
+                this.size--;
+            }
+        }
+
+        const node = {
+            key,
+            value,
+            expiresAt: Date.now() + this.ttl,
+            next: null,
+            prev: null
+        };
+
+        this.cache.set(key, node);
+        this._addToFront(node);
+        this.size++;
+        return this;
+    }
+
+    delete(key) {
+        const node = this.cache.get(key);
+        if (node) {
+            this._remove(node);
+            this.cache.delete(key);
+            this.size--;
+            return true;
+        }
+        return false;
+    }
+}
+
+// Esporta singola cache istanza module globale (singleton per memory context node)
+export const searchCache = new LRUCache({ max: 500, ttl: 5 * 60 * 1000 });

package/src/circuit-breaker.js

@@ -0,0 +1,63 @@
+/**
+ * @module circuit-breaker
+ * @description Fail-fast strategy su DDG in caso di cap HTTP bloccati IP.
+ */
+
+export class CircuitBreaker {
+    /**
+     * @param {Object} options Imposta le policies di fault limit e timeout windows.
+     */
+    constructor(options = {}) {
+        this.failureThreshold = options.failureThreshold || 5;
+        this.resetTimeout = options.resetTimeout || 60000;
+        this.state = 'CLOSED'; // CLOSED, OPEN, HALF_OPEN
+        this.failures = 0;
+        this.lastFailureTime = null;
+    }
+
+    /**
+     * @description Esegue logica async proteggendola da cascading failure DDG
+     * @param   {Function} fn - Ritorna Promise async operation DDG fetch
+     * @returns {Promise<any>} Risultato esecuzione
+     * @throws  {Error} Fallimento execution o cb open rejection error
+     */
+    async execute(fn) {
+        if (this.state === 'OPEN') {
+            if (Date.now() - this.lastFailureTime < this.resetTimeout) {
+                throw new Error('Circuit breaker is OPEN');
+            }
+            // Tentativo check dopo finestra timeout
+            this.state = 'HALF_OPEN';
+        }
+
+        try {
+            const result = await fn();
+            this.onSuccess();
+            return result;
+        } catch (err) {
+            this.onFailure();
+            throw err;
+        }
+    }
+
+    onSuccess() {
+        if (this.state === 'HALF_OPEN') {
+            this.halfOpenSuccesses = (this.halfOpenSuccesses || 0) + 1;
+            if (this.halfOpenSuccesses >= 2) {
+                this.failures = 0;
+                this.state = 'CLOSED';
+                this.halfOpenSuccesses = 0;
+            }
+        } else {
+            this.failures = 0;
+        }
+    }
+
+    onFailure() {
+        this.failures++;
+        this.lastFailureTime = Date.now();
+        if (this.failures >= this.failureThreshold) {
+            this.state = 'OPEN';
+        }
+    }
+}

package/src/cli.js

@@ -0,0 +1,58 @@
+/**
+ * @module cli
+ * @description Parsing degli argomenti CLI process.argv e logica help screen.
+ */
+import { chalk } from './logger.js';
+import { createRequire } from 'module';
+
+const { version } = createRequire(import.meta.url)('../package.json');
+
+// ─── Arg Parsers ─────────────────────────────────────
+
+const args = process.argv.slice(2);
+const usePackageJson = args.includes('--use-package-json');
+const antigravityMode = args.includes('--antigravity');
+const claudeCodeMode = args.includes('--claude-code');
+
+// Stop immediato se nessun mode definito
+if (!antigravityMode && !claudeCodeMode) {
+    console.log();
+    console.log(`  ${chalk.white.bold('GroundTruth')}  ${chalk.gray(`v${version}`)}`);
+    console.log();
+    console.log(`  Usage:`);
+    console.log(`    groundtruth --claude-code       proxy mode (Claude Code)`);
+    console.log(`    groundtruth --antigravity       rules mode (Antigravity/Gemini)`);
+    console.log();
+    console.log(`  Options:`);
+    console.log(`    --use-package-json   use package.json as search query`);
+    console.log(`    --port <n>           custom port, default 8080 (claude-code only)`);
+    console.log(`    --interval <n>       refresh in minutes, default 5 (antigravity only)`);
+    console.log(`    --batch-size <n>     deps per search batch (default: 3)`);
+    console.log();
+    console.log(`  Docs:`);
+    console.log(`    Claude Code   →  export ANTHROPIC_BASE_URL=http://localhost:8080`);
+    console.log(`    Antigravity   →  just run groundtruth --antigravity in your project`);
+    console.log();
+    process.exit(0);
+}
+
+// ─── Default params override ─────────────────────────
+
+let port = 8080; // Default Anthropic proxy
+const portArgIndex = args.indexOf('--port');
+if (portArgIndex !== -1 && args[portArgIndex + 1]) {
+    port = parseInt(args[portArgIndex + 1], 10);
+}
+
+let intervalMinutes = 5; // Default context refresh
+const intervalArgIndex = args.indexOf('--interval');
+if (intervalArgIndex !== -1 && args[intervalArgIndex + 1]) {
+    intervalMinutes = parseInt(args[intervalArgIndex + 1], 10) || 5;
+}
+
+const batchSizeIndex = args.indexOf('--batch-size');
+const batchSize = batchSizeIndex !== -1
+    ? Math.max(2, Math.min(parseInt(args[batchSizeIndex + 1]) || 3, 5))
+    : 3;
+
+export { args, usePackageJson, antigravityMode, claudeCodeMode, port, intervalMinutes, batchSize, version };