Initial commit: homelab infrastructure wiki

- Full Obsidian vault content
- Host configs (ice, grizzley, ubuntu, proxmox, truenas, panda, hyte)
- Media stack documentation
- Traefik HA setup
- Automation scripts
- Bachelor party planning

homelab/raw/articles/forge/reference/docs-commands.md

@@ -0,0 +1,98 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/docs/commands/
+scraped: 2026-04-28T21:02:35.706451+00:00
+content_hash: 8ef9d024
+---
+# Custom Commands
+
+You repeat the same workflow constantly — lint, test, fix, commit. Every time, you type it out or paste it from a notes file. Custom commands let you turn any repeatable workflow into a named slash command that ForgeCode executes on demand.
+
+## How It Works​
+
+A custom command is a Markdown file in the .forge/commands/ directory. The filename becomes the command name. The file body is the instruction ForgeCode follows when you invoke it.
+
+```
+.forge/└── commands/    ├── check.md     →  :check    └── fixme.md     →  :fixme
+```
+
+Type :check in the chat, and ForgeCode runs whatever check.md describes. That's it.
+
+## File Format​
+
+Every command file has two parts: a frontmatter block and an instruction body.
+
+```
+---name: checkdescription: Checks if the code is ready to be committed---- Run the `lint` and `test` commands and verify if everything is fine.  <lint>cargo +nightly fmt --all; cargo +nightly clippy --fix --allow-staged --allow-dirty --workspace</lint>  <test>cargo insta test --accept --unreferenced=delete</test>- Fix every issue found in the process
+```
+
+### Frontmatter​
+
+| Field | Required | Description |
+|---|---|---|
+| name | Yes | The slash command name (e.g. check → /check) |
+| description | Yes | One-line summary shown in the command picker |
+
+### Body​
+
+The body is plain Markdown. Write it the same way you'd explain the workflow to a teammate. You can use:
+
+- Prose for context or decision logic
+- Bullet lists for sequential steps
+- XML-style tags to attach literal shell commands to a step (e.g. <lint>...</lint>, <test>...</test>)
+- Code blocks for multi-line scripts
+
+ForgeCode reads the body as instructions and executes them. If a step fails, it attempts to fix the problem before continuing — just like it would for any other task.
+
+## A Minimal Example​
+
+The simplest possible command:
+
+```
+---name: fixmedescription: Looks for all the fixme comments in the code and attempts to fix them---Find all the FIXME comments in source-code files and attempt to fix them.
+```
+
+Invoke it with :fixme and ForgeCode searches every source file for FIXME comments and tries to resolve each one.
+
+## A More Complex Example​
+
+Commands can embed exact shell commands so ForgeCode runs the right tools every time:
+
+```
+---name: checkdescription: Checks if the code is ready to be committed---- Run the `lint` and `test` commands and verify if everything is fine.  <lint>cargo +nightly fmt --all; cargo +nightly clippy --fix --allow-staged --allow-dirty --workspace</lint>  <test>cargo insta test --accept --unreferenced=delete</test>- Fix every issue found in the process
+```
+
+The <lint> and <test> tags tell ForgeCode the exact commands to run for those steps. If clippy reports an error, ForgeCode fixes it. If a test fails, ForgeCode investigates. You don't have to tell it how — the command already knows.
+
+## Where to Put Commands​
+
+Commands can live in three places, loaded in precedence order:
+
+```
+.forge/commands/          ← project commands (highest precedence)~/.agents/commands/       ← shared across agent tools~/forge/commands/         ← global, across all projects
+```
+
+Project commands are the most common. Check them into version control and your team shares the same /check, /fixme, and any other workflows you define.
+
+## Invoking Commands​
+
+Type the command name with a leading slash in the ForgeCode chat:
+
+```
+:check:fixme
+```
+
+ForgeCode picks it up immediately. No restart needed — new command files are available as soon as they exist on disk.
+
+## Verifying Your Commands​
+
+To see all available commands, run :help in the chat. You'll get a list with names and descriptions.
+
+```
+:help
+```
+
+---
+
+The hardest part of getting value from custom commands is identifying which workflows deserve one. A good rule: if you've typed the same instruction three times, write a command for it.

homelab/raw/articles/forge/reference/docs-creating-agents.md

@@ -0,0 +1,161 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/docs/creating-agents/
+scraped: 2026-04-28T21:02:41.395582+00:00
+content_hash: 698f1757
+---
+# Create an Agent
+
+A custom agent is a markdown file with a YAML header. That's it. Write the system prompt the way you'd brief a skilled contractor on their role, and ForgeCode will use it every time you invoke that agent.
+
+## Where agents live​
+
+ForgeCode looks in two places:
+
+| Location | Scope | Use when |
+|---|---|---|
+| ~/forge/agents/ | Global — all projects | General-purpose agents you'll reuse everywhere |
+| .forge/agents/ | Project — current repo only | Agents specific to one codebase or team |
+
+Project agents take priority. If both locations have an agent with the same id, the project one wins.
+
+Create the directory before adding your first agent:
+
+```
+# Globalmkdir -p ~/forge/agents# Project-specificmkdir -p .forge/agents
+```
+
+## Your first agent​
+
+The minimum viable agent needs exactly one thing: a unique id.
+
+Create ~/forge/agents/security-auditor.md:
+
+```
+---id: security-auditortitle: Security Auditordescription: Reviews code for vulnerabilities and recommends fixestools:  - read  - search---You are a security specialist focused on finding and fixing vulnerabilities.Review code for injection flaws, authentication gaps, insecure data handling, and dependency risks. For every issue found, explain the risk and provide a specific fix with a code example.
+```
+
+Restart ForgeCode, then run :agent to see your new agent in the list. It is also automatically added as a : command you can invoke directly.
+
+## The file anatomy​
+
+Every agent definition is a markdown file split into two parts:
+
+```
+---# YAML frontmatter — capabilities and metadataid: my-agenttitle: My Agent---System prompt — the agent's instructions, written in plain markdown.
+```
+
+The frontmatter controls what the agent can do: which tools it has, which model it uses, how it samples. The system prompt controls how it thinks and responds.
+
+The id must be unique across all your agents. The filename doesn't matter — only the id field is used for identification.
+
+## Configuring tools​
+
+By default, agents have no tools unless you specify them. Restrict access to exactly what the agent needs. Run :tools in a ForgeCode session to see every tool available in your environment:
+
+```
+tools:  - read # Read files and directories  - write # Create and modify files  - patch # Apply targeted changes  - shell # Execute shell commands  - search # Search within files  - fetch # Retrieve external resources  - remove # Delete files  - undo # Reverse previous changes
+```
+
+Use * to grant access to every available tool:
+
+```
+tools:  - "*" # All tools
+```
+
+Do so in practice every tool definition is injected into the model's context. Granting all tools — especially when many MCP servers are configured — consumes significant context space and leaves less room for your actual work. Prefer explicit tool lists or narrow globs.
+
+For MCP integrations, use a prefix glob so new MCP servers are automatically included:
+
+```
+tools:  - read  - search  - "mcp_*" # All MCP tools — database, browser, APIs, etc.
+```
+
+A security auditor only needs read and search. A deployment agent needs shell. Match the tool list to the role — agents with fewer tools make fewer unintended changes.
+
+## Model and behavior settings​
+
+```
+---id: my-agenttitle: My Agentdescription: Brief description of what this agent does# Model selection (optional — defaults to your configured model)model: claude-sonnet-4provider: anthropic # Must be snake_case: open_router, openai, requesty, etc.# Sampling (optional)temperature: 0.1 # 0.0–2.0 — lower = more precise, higher = more creativetop_p: 0.9 # 0.0–1.0 nucleus sampling thresholdtop_k: 40 # 1–1000max_tokens: 8192 # 1–100,000# Limits (optional)max_turns: 50 # Max conversation turns before the agent stopsmax_requests_per_turn: 10max_tool_failure_per_turn: 3 # Max tool failures per turn before forcing completion# Visibility (optional)tool_supported: true # Whether this agent can be called as a tool by other agents# Reasoning (optional — for models that support it)reasoning:  enabled: true  effort: medium # low | medium | high  max_tokens: 2048 # Must be > 1024 and < max_tokens  exclude: false # Hide reasoning output from the response---
+```
+
+Keep temperature low (0.05–0.2) for agents that write code or follow strict rules. Use higher values only for agents doing creative or exploratory work.
+
+## Shaping user messages​
+
+user_prompt lets you wrap or augment every incoming user message before it reaches the model. It runs as a Handlebars template with these variables:
+
+| Variable | Value |
+|---|---|
+| {{event.name}} | task for the first message, feedback for subsequent ones |
+| {{event.value}} | The raw user input |
+| {{current_date}} | Today's date |
+
+Use it to inject structured context the model should always see — like a timestamp or a consistent envelope format:
+
+```
+user_prompt: |-  <{{event.name}}>{{event.value}}</{{event.name}}>  <system_date>{{current_date}}</system_date>
+```
+
+With this template, the first user message fix the bug becomes:
+
+```
+<task>fix the bug</task><system_date>2026-04-01</system_date>
+```
+
+And a follow-up becomes:
+
+```
+<feedback>looks good, but also handle the edge case</feedback><system_date>2026-04-01</system_date>
+```
+
+Use |- (block scalar, strip trailing newline) rather than | to avoid sending a spurious blank line at the end of every message.
+
+## Customizing built-in agents​
+
+You can override ForgeCode's built-in agents (forge, muse, sage) by creating an agent file with a matching id. The built-in definition is replaced entirely.
+
+Create .forge/agents/forge-frontend.md:
+
+```
+---id: "forge"title: "Frontend Forge"description: "Forge agent tuned for React and TypeScript"tools:  - read  - write  - patch  - shelltemperature: 0.1---You are a frontend development expert for this React TypeScript project.Build modern, accessible components. Explain architectural decisions. Include TypeScript types in every example you write.
+```
+
+This override applies only to the project — global ForgeCode sessions are unaffected.
+
+## Troubleshooting​
+
+Agent doesn't appear in :agent list
+
+- Check the file has a .md extension
+- Verify the frontmatter is valid YAML (spaces, not tabs for indentation)
+- Confirm the id is unique — duplicate IDs cause the second agent to be silently skipped
+- Restart ForgeCode after adding new agent files
+
+YAML parse errors
+
+Quote strings that contain colons, brackets, or other special characters:
+
+```
+title: "Backend: API Expert" # colon in value requires quotesdescription: "Expert [Node.js]" # brackets require quotes
+```
+
+Use | for multiline strings:
+
+```
+description: |  Analyzes code for security vulnerabilities,  explains each risk, and provides concrete fixes.
+```
+
+Agent used as a tool by other agents isn't recognized
+
+Agents can only be invoked as tools by other agents if they have a description field. An agent without description is available in the :agent picker but not as a callable tool.
+
+---
+
+## Related​
+
+- Agents — built-in agents and when to use each
+- SKILL.md — teach ForgeCode reusable workflows
+- MCP Integration — connect agents to external services
+- AGENTS.md Guide — project-wide rules for all agents

homelab/raw/articles/forge/reference/docs-custom-providers.md

@@ -0,0 +1,141 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/docs/custom-providers/
+scraped: 2026-04-28T21:02:33.328356+00:00
+content_hash: a722158f
+---
+# Custom Providers
+
+ForgeCode supports OpenRouter, OpenAI, Anthropic, Google Vertex AI, Groq, and Amazon Bedrock out of the box. For everything else — self-hosted models, enterprise API gateways, regional endpoints, or any service that speaks a supported API format — you configure a custom provider in .forge.toml.
+
+## Adding a Provider​
+
+Each provider gets a [[providers]] entry in your .forge.toml. The only required fields are id and url:
+
+```
+[[providers]]id             = "my-provider"url            = "https://my-llm-gateway.internal/v1/chat/completions"api_key_vars   = "MY_PROVIDER_API_KEY"response_type  = "OpenAI"auth_methods   = ["api_key"]
+```
+
+id is the name you'll use to reference this provider in the rest of your config and with the :provider command inside ForgeCode. url is the full chat completions endpoint. api_key_vars names the environment variable that holds the API key.
+
+## Pointing Sessions at a Provider​
+
+The [session] block sets the default model and provider for every conversation. Set provider_id to the id you defined above:
+
+```
+[session]provider_id = "my-provider"model_id    = "meta-llama/Llama-3.3-70B-Instruct"
+```
+
+You can override this per-session from inside ForgeCode using the :provider command, which lets you switch providers interactively without editing any files.
+
+## Full Provider Field Reference​
+
+| Field | Required | Description |
+|---|---|---|
+| id | Yes | Unique provider identifier used in model paths (e.g. "my_provider"). |
+| url | Yes | Chat completions URL; may contain {{VAR}} placeholders substituted from url_param_vars. |
+| api_key_vars | No | Name of the environment variable holding the API key for this provider. |
+| auth_methods | No | Authentication methods; defaults to ["api_key"]. Use ["google_adc"] for Google Application Default Credentials. |
+| custom_headers | No | Additional HTTP headers sent with every request to this provider. |
+| models | No | Model source: a URL for fetching the model list (may contain {{VAR}} placeholders), or an inline array of model objects. |
+| provider_type | No | Provider category: "llm" (default) or "context_engine" for code indexing and search. |
+| response_type | No | Wire protocol: OpenAI, OpenAIResponses, Anthropic, Bedrock, Google, or OpenCode. |
+| url_param_vars | No | List of environment variable names whose values are substituted into {{VAR}} placeholders in url and models. |
+
+## Multiple Custom Providers​
+
+You can define as many [[providers]] entries as you need:
+
+```
+[[providers]]id            = "local"url           = "http://localhost:11434/v1/chat/completions"models        = "http://localhost:11434/v1/models"response_type = "OpenAI"auth_methods  = ["api_key"][[providers]]id            = "staging-gateway"url           = "https://staging-llm.internal/v1/chat/completions"api_key_vars  = "STAGING_LLM_KEY"response_type = "OpenAI"auth_methods  = ["api_key"]
+```
+
+Switch between them with :provider at any time, or point specific operations (session, commit, suggest) at different entries.
+
+## Overriding a Built-In Provider​
+
+If your id matches a built-in provider (e.g. "openai", "anthropic"), the entry overrides that provider's fields rather than creating a new one. This lets you swap out the endpoint for a built-in provider without fully replacing it:
+
+```
+[[providers]]id            = "openai"url           = "https://openai-proxy.corp.internal/v1/chat/completions"api_key_vars  = "CORP_OPENAI_KEY"response_type = "OpenAI"auth_methods  = ["api_key"]
+```
+
+Entries with a new id are appended and become available for model selection alongside the built-ins.
+
+## Environment Variables​
+
+Both api_key_vars and url_param_vars reference environment variable names — ForgeCode reads the values from your environment at runtime. You can set them in your shell profile or in a ~/.env file, which ForgeCode loads automatically on every run:
+
+```
+# ~/.envOPENAI_API_KEY=sk-...OPENAI_URL=https://my-llm-gateway.internal/v1
+```
+
+## URL Template Variables​
+
+Both url and models support {{VAR}} placeholders. Declare the variable names to substitute in url_param_vars as a list of environment variable names:
+
+```
+[[providers]]id             = "openai_compatible"api_key_vars   = "OPENAI_API_KEY"url_param_vars = ["OPENAI_URL"]response_type  = "OpenAI"url            = "{{OPENAI_URL}}/chat/completions"models         = "{{OPENAI_URL}}/models"auth_methods   = ["api_key"]
+```
+
+At runtime ForgeCode reads the value of each variable in url_param_vars and substitutes it into the matching {{VAR}} placeholder in url and models. If a provider has no dynamic URL segments, pass an empty list: url_param_vars = [].
+
+## Static Model List​
+
+Instead of a URL, models can be an inline array of model objects. This is useful when the provider doesn't expose a model-listing endpoint, or when you want to pin the exact set of models available:
+
+```
+[[providers]]id             = "openai"api_key_vars   = "OPENAI_API_KEY"url_param_vars = []response_type  = "OpenAI"url            = "https://api.openai.com/v1/chat/completions"auth_methods   = ["api_key"][[providers.models]]id                           = "o1"name                         = "O1"description                  = "OpenAI's reasoning model with advanced problem-solving capabilities"context_length               = 200000tools_supported              = truesupports_parallel_tool_calls = truesupports_reasoning           = trueinput_modalities             = ["text"][[providers.models]]id                           = "o1-2024-12-17"name                         = "O1 (2024-12-17)"description                  = "OpenAI's reasoning model snapshot from December 2024"context_length               = 200000tools_supported              = truesupports_parallel_tool_calls = truesupports_reasoning           = trueinput_modalities             = ["text"]
+```
+
+Each model object supports the following fields:
+
+| Field | Description |
+|---|---|
+| id | Model identifier used in API requests. |
+| name | Human-readable display name. |
+| description | Short description of the model. |
+| context_length | Maximum context window size in tokens. |
+| tools_supported | Whether the model supports tool/function calling. |
+| supports_parallel_tool_calls | Whether the model can execute multiple tool calls in parallel. |
+| supports_reasoning | Whether the model supports extended reasoning / chain-of-thought. |
+| input_modalities | List of supported input types, e.g. ["text"] or ["text", "image"]. |
+
+## Custom Headers​
+
+To send additional headers with every request — for example, to pass a gateway token or routing key — use a [providers.custom_headers] table directly after the provider entry:
+
+```
+[[providers]]id            = "kimi_coding"api_key_vars  = "KIMI_API_KEY"url_param_vars = []response_type = "OpenAI"url           = "https://api.kimi.com/coding/v1/chat/completions"models        = "https://api.kimi.com/coding/v1/models"auth_methods  = ["api_key"][providers.custom_headers]User-Agent = "KimiCLI/1.0.0"
+```
+
+## Google Application Default Credentials​
+
+For providers that use Google ADC instead of an API key, set auth_methods to ["google_adc"]:
+
+```
+[[providers]]id           = "vertex-custom"url          = "https://us-central1-aiplatform.googleapis.com/v1/projects/my-project/locations/us-central1/endpoints/openapi/chat/completions"response_type = "Google"auth_methods = ["google_adc"]
+```
+
+## Provider with Custom Certificate Authority​
+
+If your endpoint sits behind a corporate proxy or uses a private CA, configure ForgeCode to trust it via the [http] section of .forge.toml:
+
+```
+[[providers]]id            = "enterprise-gateway"url           = "https://llm-gateway.corp.internal/v1/chat/completions"api_key_vars  = "CORP_LLM_KEY"response_type = "OpenAI"auth_methods  = ["api_key"][http]root_cert_paths = ["/etc/ssl/certs/corp-ca.pem"]
+```
+
+See Proxy Configuration for the full certificate and proxy setup.
+
+## Verifying the Configuration​
+
+Open the config file directly from any ForgeCode session:
+
+```
+:config-edit
+```
+
+Then switch to your provider with the :provider command to confirm it loads and responds. If ForgeCode can't reach the endpoint, it will surface a connection error — check that url is reachable and the endpoint is accessible.
+
+The full list of configuration options for .forge.toml is documented in .forge.toml.

homelab/raw/articles/forge/reference/docs-custom-rules-guide.md

@@ -0,0 +1,255 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/docs/custom-rules-guide/
+scraped: 2026-04-28T21:02:44.317839+00:00
+content_hash: 4eea922b
+---
+# Building Software Development Standards with AGENTS.md
+
+Every development team has its own way of doing things. Code style preferences, testing patterns, error handling approaches, naming conventions - the list goes on. The problem? A coding harness doesn't know your team's specific practices unless you tell them.
+
+ForgeCode's custom rules feature solves this by letting you embed your team's standards directly into every AI interaction. Instead of repeating the same guidelines in every conversation, you define them once in an AGENTS.md file and the AI follows them automatically.
+
+## What Are Project-Specific Guidelines?​
+
+Project-specific guidelines are persistent instructions that get injected into every AI conversation. Think of them as your team's development constitution - fundamental principles that should guide every decision the AI makes in your codebase.
+
+When you define project guidelines, they become part of the AI's system prompt, meaning they're always active and take priority over default behaviors.
+
+For technical implementation details and API reference, see the Custom Rules feature documentation.
+
+## Quick Start: Your First Project Guidelines​
+
+Let's start with something simple. Create an AGENTS.md file in your project root:
+
+```
+# Development Guidelines## Core Standards- Add error handling to all functions- Include unit tests for new code- Use meaningful variable names
+```
+
+That's it! Now every AI interaction will follow these three basic principles. Let's see how this works in practice.
+
+### Before Project Guidelines​
+
+```
+User: "Create a function to calculate user age"AI: [Creates basic function without error handling or tests]User: "Add error handling and tests please"AI: [Adds basic validation]
+```
+
+### After Project Guidelines​
+
+```
+User: "Create a function to calculate user age"AI: [Creates function with error handling, input validation, and comprehensive tests]User: "Perfect!"
+```
+
+## Setting Up Project Guidelines​
+
+Project guidelines are defined using an AGENTS.md file in your project root directory. This file uses markdown format for comprehensive, documentation-style guidelines.
+
+### Basic Setup (Recommended for Teams)​
+
+Create an AGENTS.md file in your project root with your team's core standards:
+
+```
+# Development Guidelines## Core Standards- Use TypeScript strict mode- Add error handling to all functions- Include unit tests for new code- Use meaningful variable names
+```
+
+### Specialized Rules by Domain​
+
+You can organize rules by different areas of development:
+
+```
+# Development Guidelines## Frontend Development- Use React functional components- Add accessibility attributes- Include PropTypes for components## Backend Development- Use dependency injection- Add request logging to endpoints- Validate all input with schemas
+```
+
+## Progressive Learning Path​
+
+### Level 1: Basic Standards (Start Here)​
+
+Perfect for teams just getting started with project guidelines:
+
+```
+# Development Guidelines## Core Standards- Add error handling to all functions- Include unit tests for new code- Use meaningful variable names- Add comments for complex logic
+```
+
+### Level 2: Language-Specific Patterns​
+
+Once comfortable with basic rules, add language-specific conventions:
+
+```
+# Development Guidelines## TypeScript Standards- Use explicit type annotations- Prefer interfaces over type aliases- Use React.memo for performance optimization## Python Standards- Use type hints for all functions- Follow PEP 8 naming conventions- Use dataclasses for data objects
+```
+
+### Level 3: Team-Specific Architecture​
+
+Advanced rules for established teams with specific patterns:
+
+```
+# Development Guidelines## Architecture Patterns- Use repository pattern for data access- Implement command/query separation- Apply dependency injection for services## Testing Standards- Use arrange-act-assert pattern- Mock external dependencies- Test both happy path and error conditions
+```
+
+## Real-World Examples by Tech Stack​
+
+### React/TypeScript Teams​
+
+```
+# React/TypeScript Development Guidelines## Core Standards- Use TypeScript strict mode- Prefer functional components with hooks- Add data-testid attributes for testing- Use React Testing Library for tests- Include JSDoc comments for props
+```
+
+### Python/Django Projects​
+
+```
+# Python/Django Development Guidelines## Core Standards- Use type hints for all functions- Keep views thin, logic in services- Use database transactions for multi-model operations- Write tests using pytest with factory_boy- Follow Django app structure conventions
+```
+
+### Node.js/Express APIs​
+
+```
+# Node.js/Express API Guidelines## Core Standards- Use async/await instead of callbacks- Add input validation with Joi schemas- Include request/response logging- Use dependency injection for services- Write integration tests for all endpoints
+```
+
+## How Project Guidelines Work​
+
+When you start an AI agent session, the system:
+
+1. Searches for AGENTS.md files in multiple locations using a priority system
+2. Parses the markdown content and extracts your guidelines from the first file found
+3. Injects guidelines into the AI's system prompt
+4. Applies guidelines to every response throughout the session
+
+The guidelines become part of the AI's "personality" for that session, influencing every decision it makes about your code.
+
+### File Location Priority​
+
+The system searches for AGENTS.md files in three locations in order of priority:
+
+- Base path (environment.base_path) - highest priority
+- Git root directory (if available) - medium priority
+- Current working directory (environment.cwd) - lowest priority
+
+The system uses the first AGENTS.md file it finds, starting from the base path and working down the priority list.
+
+## Advanced Strategies​
+
+### Conditional Rules by File Type​
+
+```
+# Development Guidelines## File-Specific Standards### TypeScript Files (.ts/.tsx)- Use explicit type annotations- Add JSDoc comments for public APIs### Python Files (.py)- Use type hints following PEP 484- Format with black and sort imports with isort### SQL Files (.sql)- Use uppercase for SQL keywords- Add comments explaining complex queries
+```
+
+### Environment-Specific Rules​
+
+```
+# Development Guidelines## Environment Standards### Development Environment- Include detailed logging and debug information- Add comprehensive error messages### Production Environment- Use structured logging with correlation IDs- Implement graceful error handling- Add performance monitoring
+```
+
+## Troubleshooting​
+
+### Common Issues and Solutions​
+
+Problem: Guidelines aren't being applied
+
+- Check your AGENTS.md file is in your project root directory
+- Ensure the file is named exactly AGENTS.md (case-sensitive)
+- Verify the markdown syntax is valid
+- Restart your AI agent session after making changes
+
+Problem: Guidelines conflict with each other
+
+- Review your AGENTS.md file for contradictory statements
+- Later guidelines in the same section may override earlier ones
+- Be specific about when guidelines apply (file types, contexts)
+
+Problem: Guidelines are too vague
+
+```
+<!-- Too vague --># Guidelines- Write good code- Add tests- Handle errors<!-- Better --># Guidelines- Add error handling with try/catch blocks- Include unit tests with arrange-act-assert pattern
+```
+
+Problem: Too many guidelines causing confusion
+
+- Start with 3-5 core guidelines
+- Add new guidelines gradually as patterns emerge
+- Group related guidelines under clear categories
+
+### Debugging Your Guidelines​
+
+To verify your guidelines are active, ask the AI agent to describe what project guidelines it's currently following. The guidelines from AGENTS.md will be part of the AI's system prompt and influence all responses.
+
+### Performance Tips​
+
+- Keep guidelines concise and specific
+- Use bullet points for better readability
+- Group related guidelines under clear headings
+- Avoid duplicate or contradictory guidelines
+
+## Best Practices​
+
+### Writing Effective Guidelines​
+
+Do:
+
+- Be specific about what you want
+- Use action-oriented language ("Add", "Use", "Include")
+- Group related guidelines together
+- Start simple and iterate
+
+Don't:
+
+- Write vague instructions ("write good code")
+- Create conflicting guidelines
+- Add too many guidelines at once
+- Forget to test your guidelines
+
+### Team Adoption​
+
+1. Start with team consensus - Get buy-in on 3-5 core guidelines
+2. Document the why - Explain reasoning behind each guideline
+3. Review regularly - Update guidelines as practices evolve
+4. Share examples - Show before/after comparisons
+
+## Getting Started Checklist​
+
+- Create an AGENTS.md file in your project root
+- Add 3-5 basic project guidelines using markdown format
+- Test with a small feature implementation
+- Ask the AI to describe what guidelines it's following
+- Iterate based on results
+- Gradually add more specific guidelines
+
+---
+
+## Need Help?​
+
+### Verify Your Guidelines​
+
+Ask the AI agent: "What project guidelines are you currently following?" or "Can you summarize the development guidelines you're using?" to verify your AGENTS.md file is being loaded correctly.
+
+### Get Support​
+
+- Discord: Join our Discord community
+- Twitter/X: Send us a DM @forgecodehq
+
+---
+
+### Common Questions​
+
+Q: Can I have different guidelines for different projects? A: Yes! Each project's AGENTS.md file can have its own specific guidelines.
+
+Q: How many guidelines can I add? A: There's no hard limit, but we recommend starting with 5-10 guidelines and growing gradually.
+
+Q: Do guidelines apply to all AI models? A: Yes, project guidelines work with all supported AI models.
+
+Q: Can I share guidelines between projects? A: You can copy guidelines between AGENTS.md files, or create a template for your organization.
+
+---
+
+Project-specific guidelines transform AI coding from a series of corrections into a smooth, standards-compliant workflow. Your AI learns your team's way of doing things once through your AGENTS.md file, then applies that knowledge consistently across every development session.
+
+## Related Guides​
+
+To maximize your team's productivity with ForgeCode, explore these complementary guides:
+
+- Agent Selection Guide - Choose the right AI assistant for your specific development tasks
+- Model Selection Guide - Choose the right AI models for your specific development tasks
+- File Tagging - Use @ mentions to provide better context for AI code generation
+- Plan and Act Guide - Structure your development workflow with AI planning before implementation

homelab/raw/articles/forge/reference/docs-custom-rules.md

@@ -0,0 +1,51 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/docs/custom-rules/
+scraped: 2026-04-28T21:02:27.349364+00:00
+content_hash: 227b8e99
+---
+# AGENTS.md
+
+Project guidelines allow you to define specific development standards and instructions that shape how AI agents behave in your project. These guidelines act as persistent instructions that get injected into every AI conversation.
+
+For comprehensive examples, team management strategies, and real-world use cases, check out our Project Guidelines Guide.
+
+## Getting Started​
+
+Project guidelines are defined using an AGENTS.md file in your project root directory. This file uses markdown format for comprehensive, documentation-style guidelines.
+
+AGENTS.md is equivalent to CLAUDE.md. You can copy content directly between CLAUDE.md and AGENTS.md without changing instructions.
+
+Quick Start:
+
+1. Create AGENTS.md in your project root directory
+2. Write your development guidelines using markdown
+3. Guidelines are automatically loaded when the agent starts
+
+The AGENTS.md file is ideal for:
+
+- Comprehensive development standards
+- Project-specific architecture patterns
+- Detailed coding conventions
+- Team workflows and best practices
+
+AGENTS.md supports full markdown formatting including headings, lists, code blocks, and emphasis. This makes it perfect for detailed documentation-style guidelines.
+
+## Complete Example​
+
+Here's a real-world AGENTS.md file for a full-stack web application:
+
+```
+# Development Guidelines for MyApp## 📋 Core Development Rules### Application Runtime- **NEVER** attempt to run the application - it's already running on port 3000 in watch mode- The development server is persistent and handles hot reloading automatically- Always assume the application is accessible at `http://localhost:3000`### Package Management- **Use**: `npm` or `npx` commands exclusively- **Avoid**: `yarn` or `pnpm` - not used in this project- Always check `package.json` for available scripts before running commands### Code Quality Standards- **TypeScript First**: All code must be type-safe with proper type definitions- **Component Architecture**: Follow React functional components with hooks- **Responsive Design**: Ensure all UI components work across devices- **Error Handling**: Always wrap async operations in try-catch blocks## 🛠️ Project Structure```├── src/│   ├── components/      # Reusable React components│   ├── pages/           # Next.js pages│   ├── services/        # API calls and business logic│   ├── utils/           # Helper functions│   └── styles/          # Global styles and themes├── public/              # Static assets└── tests/               # Test files```## 🎯 Development Focus Areas### API Integration- All API calls must go through the `services/` directory- Use the custom `apiClient` wrapper for consistent error handling- Never hardcode API endpoints - use environment variables### State Management- Use React Context for global state- Keep component state local when possible- Avoid prop drilling - use context or composition### Testing- Write unit tests for all utility functions- Use React Testing Library for component tests- Aim for 80% code coverage on new features## 🚫 Restrictions & Limitations### What NOT to do:- ❌ Run `npm start` or similar server commands (server is already running)- ❌ Use `any` type in TypeScript- ❌ Create non-responsive components- ❌ Skip error handling in async functions### What TO do:- ✅ Use existing development server- ✅ Write TypeScript-first code with proper types- ✅ Follow mobile-first responsive design- ✅ Add comprehensive error handling- ✅ Write tests for new features## 📝 Code Style- Use functional components with hooks (no class components)- Prefer `const` over `let`, avoid `var`- Use arrow functions for callbacks- Keep functions small and focused (max 50 lines)- Use meaningful variable names (no single letters except loop counters)## 🔍 Before Completing Any Task- [ ] Code is TypeScript compliant with proper types- [ ] Components are responsive and accessible- [ ] Error handling is implemented- [ ] No attempts to restart the development server- [ ] Tests are written and passing
+```
+
+This example shows how to structure comprehensive guidelines that cover runtime behavior, code standards, project structure, and team conventions all in one place.
+
+## How It Works​
+
+When you start an AI agent session:
+
+1. Loading: The system searches for AGENTS.md files in three locations in order of priority: Base path (~/forge) - highest priority Git root directory (if available) - medium priority Current working directory (pwd) - lowest priority
+2. Injection: All guidelines from the found file become part of the AI's system prompt
+3. Application: AI applies all guidelines to every response in the session

homelab/raw/articles/forge/reference/docs-editor-configuration.md

@@ -0,0 +1,103 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/docs/editor-configuration/
+scraped: 2026-04-28T21:02:32.607096+00:00
+content_hash: 87c5d783
+---
+# $EDITOR
+
+Typing a five-line prompt in a single-line input is miserable. The :edit command lets you compose prompts in a real editor — VS Code, Vim, Neovim, nano, whatever you prefer — then sends the result to ForgeCode when you save and close.
+
+```
+:edit
+```
+
+Your editor opens a temporary file. Write your prompt, save, close. ForgeCode reads the file and sends it as if you had typed it inline.
+
+## Setting Your Editor​
+
+ForgeCode checks two environment variables, in order:
+
+| Variable | Scope | Example Value |
+|---|---|---|
+| FORGE_EDITOR | ForgeCode only | code --wait |
+| EDITOR | System-wide | vim |
+
+FORGE_EDITOR takes priority. If it's set, EDITOR is ignored. If neither is set, :edit has no editor to open and will not work.
+
+FORGE_EDITOR exists for one reason: your preferred system editor and your preferred prompt editor might not be the same. Maybe you use vim for quick system edits but want VS Code for longer prompts. Set FORGE_EDITOR to decouple the two.
+
+### VS Code​
+
+VS Code needs the --wait flag so ForgeCode knows when you're done editing. Without it, the code command returns immediately and ForgeCode sends an empty prompt.
+
+```
+export FORGE_EDITOR="code --wait"
+```
+
+### Vim / Neovim​
+
+Vim and Neovim run inside your terminal and block until you quit, so no extra flags are needed:
+
+```
+export EDITOR="vim"# orexport EDITOR="nvim"
+```
+
+### nano​
+
+```
+export EDITOR="nano"
+```
+
+### Other Editors​
+
+Any editor that blocks the calling process until the file is closed will work. The pattern is the same — if your editor returns immediately, look for a "wait" or "block" flag in its docs.
+
+| Editor | Command |
+|---|---|
+| Sublime Text | subl --wait |
+| IntelliJ IDEA | idea --wait |
+| Zed | zed --wait |
+| Emacs (GUI) | emacsclient -c |
+| Emacs (terminal) | emacs -nw |
+
+## Where to Set It​
+
+Three options, same trade-offs as any environment variable.
+
+~/.env — persistent, ForgeCode-only
+
+ForgeCode loads ~/.env on every run. The variable is invisible to other tools:
+
+```
+# ~/.envFORGE_EDITOR=code --wait
+```
+
+~/.zshrc (or ~/.bashrc) — persistent, system-wide
+
+Makes the variable available to everything in your shell:
+
+```
+# ~/.zshrcexport EDITOR="vim"
+```
+
+Reload your shell after editing (source ~/.zshrc) or open a new terminal.
+
+Current session — temporary
+
+```
+export FORGE_EDITOR="code --wait"
+```
+
+Gone when the session ends.
+
+## When to Use :edit​
+
+Inline prompts work fine for short requests. :edit earns its keep when:
+
+- The prompt has structure — steps, lists, code snippets, or multi-paragraph context that's awkward to compose in a single line.
+- You want to iterate — write a draft, re-read it, tighten it up before sending. A real editor with cursor movement, undo, and search makes this natural.
+- You're pasting content — logs, stack traces, or code blocks are easier to arrange in an editor than at a prompt.
+
+Pair it with multiline input for shorter structured prompts, and reach for :edit when the prompt outgrows inline composition.

homelab/raw/articles/forge/reference/docs-file-tagging.md

@@ -0,0 +1,65 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/docs/file-tagging/
+scraped: 2026-04-28T21:02:37.418968+00:00
+content_hash: a245326b
+---
+# File Tagging
+
+File tagging lets you attach project context directly in your prompt with @ references.
+
+`TAB`
+Type @ followed by a partial file or directory name, then press TAB. A fuzzy picker opens — type to filter, arrow keys to navigate, Enter to select. The full path is inserted automatically.
+
+```
+: explain the logic in @src/utils/helper<TAB>: review @package<TAB>
+```
+
+.gitignore is respected; ignored paths won't appear in the list.
+
+## What you can tag​
+
+Files can be ignored using Ignoring Files. Ignored files and directories are not listed in tagging suggestions.
+
+### Files​
+
+Tag a file to give ForgeCode direct code context:
+
+```
+@[src/auth/AuthService.ts]
+```
+
+### Directories​
+
+Tag a directory when you want to work across a folder:
+
+```
+@[src/components]
+```
+
+This is useful when your task spans multiple related files.
+
+### Images​
+
+Tag images for visual context (UI states, mockups, diagrams):
+
+```
+@[assets/button-states.png]@[docs/wireframes/user-journey.jpg]
+```
+
+Supported formats include PNG, JPG, JPEG, SVG, and WebP.
+
+## Why use tagging​
+
+Tagged files are auto-attached to the prompt, so the agent gets context immediately. This saves a round trip where you would otherwise need to re-send or paste content manually.
+
+## Important limitation​
+
+Be careful when tagging very large files. Extremely large files can fail to attach due to size limits.
+
+When that happens, tag smaller scopes instead:
+
+- Use a more focused file
+- Use line ranges like @[src/auth/AuthService.ts:120:180]
+- Split the task across multiple smaller tags

homelab/raw/articles/forge/reference/docs-forge-bin.md

@@ -0,0 +1,94 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/docs/forge-bin/
+scraped: 2026-04-28T21:02:19.300082+00:00
+content_hash: 520e6a0a
+---
+# $FORGE_BIN
+
+When you install ForgeCode normally, the binary lands in your $PATH as forge. The ZSH plugin assumes that name and calls it directly. That works until it doesn't — when you're testing a local build, running a binary at an absolute path, or keeping multiple versions side by side.
+
+FORGE_BIN lets you tell the ZSH plugin exactly which binary to use instead.
+
+## What It Controls​
+
+The ZSH plugin sources its shell integration at startup:
+
+```
+source <($FORGE_BIN extension zsh)
+```
+
+Every time you invoke ForgeCode from the shell, $FORGE_BIN is the command that runs. Change it and you change which binary answers.
+
+The default is forge — whatever which forge resolves to on your system.
+
+## When to Change It​
+
+Local build from source. You've compiled ForgeCode locally and want to test your changes without installing the binary system-wide:
+
+```
+export FORGE_BIN=/path/to/forgecode/target/debug/forge
+```
+
+Non-standard install path. The binary is on disk but not in a directory on your $PATH:
+
+```
+export FORGE_BIN=/opt/forgecode/bin/forge
+```
+
+Multiple versions. You have a stable release as forge and want to test a nightly build without replacing it:
+
+```
+export FORGE_BIN=~/bin/forge-nightly
+```
+
+In each case, the ZSH plugin picks up the change and routes every invocation through the specified binary.
+
+## Setting It​
+
+~/.zshrc — persistent
+
+This is the right place for FORGE_BIN. It must be set before the ZSH plugin is sourced, so it belongs in your shell profile rather than ~/.env:
+
+```
+# ~/.zshrcexport FORGE_BIN=/path/to/your/forge# This line sources the ZSH integration using $FORGE_BINsource <($FORGE_BIN extension zsh)
+```
+
+Reload your shell after editing:
+
+```
+source ~/.zshrc
+```
+
+Current session — temporary
+
+To switch binaries for just the current terminal session:
+
+```
+export FORGE_BIN=~/builds/forge-devsource <($FORGE_BIN extension zsh)
+```
+
+The change disappears when the session ends. This is useful for one-off testing without touching your permanent configuration.
+
+## Verifying the Change​
+
+After setting FORGE_BIN, confirm the right binary is being used:
+
+```
+echo $FORGE_BIN          # shows the path you set$FORGE_BIN --version     # confirms the binary responds and shows its version
+```
+
+If $FORGE_BIN --version fails, the path is wrong or the binary isn't executable. Double-check the path and run chmod +x $FORGE_BIN if needed.
+
+## Reverting to the Default​
+
+Unset the variable to go back to the system-installed forge:
+
+```
+unset FORGE_BINsource <(forge extension zsh)
+```
+
+Or remove the export FORGE_BIN=... line from your ~/.zshrc and reload.
+
+For everything else the ZSH integration can do — agent selection, multiline input, file tagging — see the ZSH Support reference.

homelab/raw/articles/forge/reference/docs-forge-config.md

@@ -0,0 +1,94 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/docs/forge-config/
+scraped: 2026-04-28T21:02:35.924185+00:00
+content_hash: f14952b2
+---
+# $FORGE_CONFIG
+
+By default, ForgeCode keeps its configuration at ~/forge/ on macOS/Linux and %USERPROFILE%\forge on Windows. That stops working when you want the config in a dotfiles repo, on a different volume, or switched per environment.
+
+FORGE_CONFIG points ForgeCode at a different directory.
+
+## What It Controls​
+
+When FORGE_CONFIG is unset, ForgeCode reads from ~/forge/.forge.toml.
+
+Set it to a directory path and ForgeCode uses that path instead:
+
+```
+export FORGE_CONFIG=~/.config/forgecode
+```
+
+ForgeCode will look for ~/.config/forgecode/.forge.toml. The directory must exist. If .forge.toml is missing inside, ForgeCode starts with defaults.
+
+## When to Change It​
+
+Dotfiles repo:
+
+```
+export FORGE_CONFIG=~/.config/forgecode
+```
+
+Multiple environments — switch configs for work vs personal:
+
+```
+export FORGE_CONFIG=~/.config/forgecode-work
+```
+
+Different volume — home directory is full or slow:
+
+```
+export FORGE_CONFIG=/data/forgecode
+```
+
+## Setting It​
+
+~/.env — ForgeCode-only, persistent:
+
+```
+FORGE_CONFIG=~/.config/forgecode
+```
+
+~/.zshrc — system-wide, persistent:
+
+```
+export FORGE_CONFIG=~/.config/forgecode
+```
+
+Reload after editing: source ~/.zshrc
+
+Current session — temporary:
+
+```
+export FORGE_CONFIG=~/test-config
+```
+
+## Verifying the Change​
+
+Check the variable:
+
+```
+echo $FORGE_CONFIG
+```
+
+Then run :config-edit in a ForgeCode session. Your editor should open $FORGE_CONFIG/.forge.toml.
+
+## Reverting to the Default​
+
+```
+unset FORGE_CONFIG
+```
+
+Or remove the line from ~/.zshrc and reload.
+
+## Migrating an Existing Config​
+
+Move the directory:
+
+```
+mv ~/forge ~/.config/forgecodeexport FORGE_CONFIG=~/.config/forgecode
+```
+
+For the full list of settings inside the config file, see the .forge.toml reference.

homelab/raw/articles/forge/reference/docs-forge-services.md

@@ -0,0 +1,76 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/docs/forge-services/
+scraped: 2026-04-28T21:02:42.078337+00:00
+content_hash: bea49a53
+---
+# ForgeCode Services
+
+ForgeCode Services is the runtime layer that helps the model stay on trajectory while it explores, edits, and executes tools.
+
+## What it does​
+
+These are the most visible capabilities, not the full feature set.
+
+- Context engine: Beats SOTA across retrieval benchmarks, uses up to 93% fewer tokens, and stays fast while starting the agent in the most relevant files and functions.
+- Tool-call guardrails: Catches invalid arguments, common tool-call mistakes, then auto-corrects them before they fail.
+- Skill engine: Assists the model in choosing the right skill for the job, so task-specific guidance is applied at the right time.
+
+There is nothing to configure here. After you enable it, it keeps running in the background.
+
+## Enable ForgeCode Services​
+
+Run:
+
+```
+:login
+```
+
+Then select ForgeServices in the provider list and complete browser authentication.
+
+No API key required — sign in with Google or GitHub.
+
+## Enable semantic sync for your project​
+
+Run:
+
+```
+:sync
+```
+
+This indexes your project and enables sem_search.
+
+To monitor indexing progress and see which files are being synced, run:
+
+```
+:sync-status
+```
+
+## Ignoring files​
+
+Files can be ignored using Ignoring Files.
+
+If a file is ignored, ForgeCode Services excludes it from sync, and the context engine cannot use that file for retrieval.
+
+## Verify services are active​
+
+Run:
+
+```
+:tools
+```
+
+Look for sem_search under SYSTEM.
+
+## Disable ForgeCode Services​
+
+Run:
+
+```
+:logout
+```
+
+This signs you out and disables ForgeCode Services.
+
+To enable again later, run :login, select ForgeServices, then run :sync for the project you want indexed.

homelab/raw/articles/forge/reference/docs-forge-term.md

@@ -0,0 +1,76 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/docs/forge-term/
+scraped: 2026-04-28T21:02:31.346623+00:00
+content_hash: 455dac30
+---
+# $FORGE_TERM
+
+When you run : fix this after a failed command, ForgeCode has no idea what you just ran. It can't see your last cargo build output or know that npm test exited with code 1. You end up narrating your terminal back to an agent sitting right next to it. That's backwards.
+
+FORGE_TERM is on by default. The zsh plugin tracks the commands you run — what they were, whether they succeeded, and when — and passes that history to ForgeCode every time you invoke :. The agent knows what you ran and what failed without you explaining any of it.
+
+This changes the interaction from:
+
+```
+# you have to reconstruct what already happened: the build failed with a type error in src/main.rs on line 42 because...
+```
+
+to:
+
+```
+cargo build  # fails: fix it     # ForgeCode already knows what failed
+```
+
+## Disabling It​
+
+Context capture is on by default. To turn it off for the current session:
+
+```
+export FORGE_TERM=false
+```
+
+To disable it permanently, add to ~/.env (ForgeCode-only) or ~/.zshrc (shell-wide):
+
+```
+FORGE_TERM=false
+```
+
+Reload after editing: source ~/.zshrc
+
+To re-enable:
+
+```
+unset FORGE_TERM
+```
+
+## Verifying It Works​
+
+Check the variable is set:
+
+```
+echo $FORGE_TERM
+```
+
+Then run a command and ask ForgeCode about it:
+
+```
+cargo build: what just failed?
+```
+
+If ForgeCode references the command you just ran, context capture is working.
+
+## Controlling Buffer Size​
+
+FORGE_TERM_MAX_COMMANDS sets how many commands the plugin keeps in the buffer. The default is 5.
+
+```
+export FORGE_TERM_MAX_COMMANDS=20
+```
+
+A larger buffer gives ForgeCode more history to work with, at the cost of a larger context window. If your prompts are hitting model context limits, lower it. If you work in long pipelines where ForgeCode needs to see further back, raise it.
+
+## What Comes Next​
+
+Once FORGE_TERM is set, : fix it means exactly what it says — ForgeCode knows the last thing that broke without you narrating it. The rest of the zsh integration — agent switching, file tagging, conversation management — is covered in ZSH Support.

homelab/raw/articles/forge/reference/docs-forgecode-config.md

@@ -0,0 +1,22 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/docs/forgecode-config/
+scraped: 2026-04-28T21:02:45.026103+00:00
+content_hash: 616289e9
+---
+# .forge.toml
+
+ForgeCode's global configuration lives at ~/.forge/.forge.toml. This file controls limits, model sampling parameters, retry behaviour, HTTP settings, context compaction, and automatic updates.
+
+To open it in your default editor, run :config-edit from any ForgeCode session:
+
+```
+:config-edit
+```
+
+You can also edit the file directly with any text editor. Changes take effect the next time ForgeCode starts.
+
+```
+$schema https://forgecode.dev/schema.json# Whether to automatically open HTML dump files in the browserauto_open_dump = false# Maximum number of conversations to show in listmax_conversations = 100# Maximum number of file extensions to include in the system promptmax_extensions = 15# Maximum characters for fetch contentmax_fetch_chars = 50000# Maximum number of files that can be read in a single batch operationmax_file_read_batch_size = 50# Maximum file size in bytes for operationsmax_file_size_bytes = 104857600# Maximum image file size in bytes for binary read operationsmax_image_size_bytes = 262144# Maximum characters per line for file read operationsmax_line_chars = 2000# Maximum number of files read concurrently in parallel operationsmax_parallel_file_reads = 64# Maximum number of lines to read from a filemax_read_lines = 2000# Maximum number of requests that can be made in a single turnmax_requests_per_turn = 100# The maximum number of lines returned for FSSearchmax_search_lines = 1000# Maximum bytes allowed for search resultsmax_search_result_bytes = 10240# Maximum number of results to return from initial vector searchmax_sem_search_results = 100# Maximum characters per line for shell outputmax_stdout_line_chars = 500# Maximum lines for shell output prefixmax_stdout_prefix_lines = 100# Maximum lines for shell output suffixmax_stdout_suffix_lines = 100# Maximum tokens the model may generate per response for all agents (1–100,000)max_tokens = 20480# Maximum tool failures per turn before the orchestrator forces completionmax_tool_failure_per_turn = 3# TTL in seconds for the model API list cachemodel_cache_ttl_secs = 604800# Whether the application is running in restricted mode; when true, tool execution requires explicit permission grantsrestricted = false# Top-k parameter for relevance filtering during semantic searchsem_search_top_k = 10# URL for the indexing serverservices_url = "https://api.forgecode.dev/"# Whether tool use is supported in the current environment; when false, tool calls are disabled regardless of agent configurationtool_supported = true# Maximum execution time in seconds for a single tool calltool_timeout_secs = 300# Top-k vocabulary cutoff for all agents; restricts sampling to the k highest-probability tokens (1–1000)top_k = 30# Nucleus sampling threshold for all agents; limits token selection to the top cumulative probability mass (0.0–1.0)top_p = 0.8[retry]# Backoff multiplication factor for each retry attemptbackoff_factor = 2# Initial backoff delay in milliseconds for retry operationsinitial_backoff_ms = 200# Maximum number of retry attemptsmax_attempts = 8# Minimum delay in milliseconds between retry attemptsmin_delay_ms = 1000# HTTP status codes that should trigger retriesstatus_codes = [429, 500, 502, 503, 504, 408, 522, 520, 529]# Whether to suppress retry error logging and eventssuppress_errors = false[http]# Accept invalid certificatesaccept_invalid_certs = false# Adaptive window sizing for improved flow controladaptive_window = true# Connection timeout in secondsconnect_timeout_secs = 30# Use Hickory DNS resolverhickory = false# Keep-alive interval in secondskeep_alive_interval_secs = 60# Keep-alive timeout in secondskeep_alive_timeout_secs = 10# Keep-alive while connection is idlekeep_alive_while_idle = true# Maximum number of HTTP redirects to followmax_redirects = 10# Connection pool idle timeout in secondspool_idle_timeout_secs = 90# Maximum idle connections per host in the connection poolpool_max_idle_per_host = 5# Read timeout in secondsread_timeout_secs = 900# TLS backend to use ("default" or "rustls")tls_backend = "default"[compact]# Maximum percentage of the context that can be summarized during compaction (0.0–1.0)eviction_window = 0.2# Maximum number of tokens to keep after compactionmax_tokens = 2000# Maximum number of messages before triggering compactionmessage_threshold = 200# Whether to trigger compaction when the last message is from a useron_turn_end = false# Number of most recent messages to preserve during compaction; these messages won't be considered for summarizationretention_window = 6# Maximum number of tokens before triggering compactiontoken_threshold = 100000[updates]# Whether to automatically install updates without promptingauto_update = true# How frequently ForgeCode checks for updates ("daily", "weekly", or "always")frequency = "daily"
+```

homelab/raw/articles/forge/reference/docs-ignoring-files.md

@@ -0,0 +1,148 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/docs/ignoring-files/
+scraped: 2026-04-28T21:02:18.076830+00:00
+content_hash: 9596cd1f
+---
+# .ignore
+
+ForgeCode respects your existing .gitignore and .ignore patterns automatically. If you've already set up .gitignore for your project, you're done. ForgeCode reads it and applies those rules immediately.
+
+The system is designed to work the way you'd expect: keep sensitive files out of Git with .gitignore, and use .ignore when you need to hide files from ForgeCode's context without affecting Git.
+
+## Quick Start​
+
+Already have a .gitignore? You're done. ForgeCode uses it automatically.
+
+Need additional ignore rules? Create a .ignore file in your project root.
+
+Files still showing up? Check troubleshooting below.
+
+## How It Works​
+
+ForgeCode checks multiple ignore sources when deciding whether to show a file. Here's the order of precedence (highest to lowest):
+
+1. .ignore files - Highest priority, overrides everything else
+2. .gitignore files - Standard Git ignore patterns
+3. Global gitignore - Your personal ignore file (~/.config/git/ignore)
+4. .git/info/exclude - Repository-specific excludes
+
+Key rule: .ignore always wins. If you whitelist a file in .ignore (using !pattern), it will be visible even if .gitignore hides it.
+
+### What Gets Filtered Out​
+
+ForgeCode automatically skips:
+
+- Files matched by ignore patterns - Checked in the precedence order above
+- Binary files - Non-text content is excluded
+- Hidden files - Files starting with . (except in your project root)
+
+Hidden file examples:
+
+- .env in project root → Visible ✓
+- .env in src/ subdirectory → Hidden ✗
+- .cache/ directory → Hidden ✗ (starts with .)
+- src/.DS_Store → Hidden ✗ (hidden file in subdirectory)
+
+To show a hidden file: Add !.filename to your .ignore file
+
+## Troubleshooting​
+
+### I Can't Find My File​
+
+First, figure out WHY it's hidden. Common causes:
+
+1. Matched by an ignore pattern (.gitignore or .ignore)
+2. Hidden file or directory (starts with . and not in project root)
+3. Binary or non-text file (ForgeCode skips these)
+
+Check if Git is ignoring it:
+
+```
+git check-ignore -v path/to/file
+```
+
+Example output:
+
+```
+.gitignore:3:node_modules/    node_modules/package/index.js
+```
+
+This means line 3 of .gitignore is hiding it.
+
+Important: git check-ignore only checks .gitignore patterns. It won't tell you if a file is hidden by .ignore or other ForgeCode-specific filters.
+
+If git check-ignore shows nothing but the file is still hidden:
+
+- Check your .ignore file (Git doesn't know about .ignore files)
+- Verify the file isn't in a hidden directory (like .cache/)
+- Confirm it's a text file, not binary
+
+To make a file visible:
+
+If hidden by .gitignore, add to .ignore:
+
+```
+!path/to/file
+```
+
+If it's a hidden file (starts with .), add to .ignore:
+
+```
+!.important-config
+```
+
+Remember: Changes to ignore files require restarting your ForgeCode session.
+
+### My Ignore Patterns Aren't Working​
+
+Pattern syntax checklist:
+
+✓ Use / for paths (even on Windows): src/build/ not src\build\ ✓ Add trailing / for directories: dist/ not dist ✓ Patterns are relative to the ignore file location ✓ Use * for wildcards: *.log matches all .log files ✓ Use ** for recursive matching: **/temp/ matches temp/ anywhere
+
+Test your pattern:
+
+```
+# Check if a specific file matchesgit check-ignore -v path/to/file# Find all files matching a patternfind . -name "*.log"# Check which of those are ignoredgit check-ignore -v $(find . -name "*.log")
+```
+
+Precedence issues:
+
+If a file should be ignored but isn't:
+
+1. Check if it's whitelisted with ! in a .ignore file
+2. Verify the pattern is in the right ignore file (.ignore overrides .gitignore)
+3. Check for more nested ignore files that might override parent patterns
+
+Still not working?
+
+- Verify your ignore file is saved
+- Restart your ForgeCode session (ignore rules are loaded at startup)
+- Check for typos in file paths
+
+### Still Having Issues?​
+
+If you've tried the steps above and still can't figure out why a file is hidden or visible, export your session diagnostics:
+
+```
+:dump html
+```
+
+Then share the output in Discord along with:
+
+1. The specific file path you're trying to ignore or include
+2. Your .gitignore and .ignore contents (or the relevant patterns)
+3. What you expected vs. what's actually happening
+4. Output from git check-ignore -v path/to/file
+
+This information helps us debug whether it's a pattern issue, precedence problem, or something else entirely.
+
+## Related Documentation​
+
+- Tag Files - Reference specific files or code sections
+- AGENTS.md - Define project-specific AI guidelines
+
+---
+
+Need help? Export your session (:dump html) and reach out on Discord

homelab/raw/articles/forge/reference/docs-mcp-integration.md

@@ -0,0 +1,255 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/docs/mcp-integration/
+scraped: 2026-04-28T21:02:43.447257+00:00
+content_hash: 79ade065
+---
+# .mcp.json
+
+MCP lets ForgeCode connect agents to external tools, APIs, and services.
+
+## What MCP gives you​
+
+With MCP, your agents can:
+
+- Call external APIs and web services
+- Use specialized tools from local or remote servers
+- Automate browser workflows
+- Connect to internal services and data systems
+
+## Quick start​
+
+Start with one command, confirm it loaded, then use the tools.
+
+```
+forge mcp import '{  "mcpServers": {    "playwright": {      "command": "npx",      "args": ["@playwright/mcp@latest"]    }  }}'forge mcp list
+```
+
+## CLI command reference​
+
+### forge mcp import​
+
+Import one or more MCP servers from a JSON string.
+
+Usage
+
+```
+forge mcp import [OPTIONS] '<json_configuration>'
+```
+
+Options
+
+- -s, --scope <SCOPE>: local or user (default: local)
+- --porcelain: machine-readable output
+
+Examples
+
+Add multiple servers to local scope:
+
+```
+forge mcp import '{  "mcpServers": {    "context7": {      "url": "https://mcp.context7.com/sse"    },    "deepwiki": {      "url": "https://mcp.deepwiki.com/sse"    },    "playwright": {      "command": "npx",      "args": ["@playwright/mcp@latest"]    }  }}'
+```
+
+Add a server to user scope:
+
+```
+forge mcp import --scope user '{  "mcpServers": {    "playwright": {      "command": "npx",      "args": ["@playwright/mcp@latest"]    }  }}'
+```
+
+Typical output:
+
+```
+⏺ Added MCP server 'context7'⏺ Added MCP server 'deepwiki'⏺ Added MCP server 'playwright'
+```
+
+### forge mcp list​
+
+List configured MCP servers.
+
+Usage
+
+```
+forge mcp list
+```
+
+Options
+
+- --porcelain: machine-readable output
+
+### forge mcp show​
+
+Show full configuration for one server.
+
+Usage
+
+```
+forge mcp show <server_name>
+```
+
+Options
+
+- --porcelain: machine-readable output
+
+Shows command or URL, arguments, environment variables, and final resolved config.
+
+### forge mcp remove​
+
+Remove one MCP server from a selected scope.
+
+Usage
+
+```
+forge mcp remove [OPTIONS] <server_name>
+```
+
+Options
+
+- -s, --scope <SCOPE>: local or user (default: local)
+- --porcelain: machine-readable output
+
+Examples
+
+```
+# Remove from local project configforge mcp remove playwright# Remove from user configforge mcp remove --scope user playwright
+```
+
+### forge mcp reload​
+
+Reload MCP servers after configuration changes.
+
+Usage
+
+```
+forge mcp reload
+```
+
+Options
+
+- --porcelain: machine-readable output
+
+Use this after editing .mcp.json manually.
+
+## Manual configuration​
+
+If you prefer direct file editing, create or update .mcp.json.
+
+```
+{  "mcpServers": {    "browser_automation": {      "command": "npx",      "args": ["@modelcontextprotocol/server-browser"],      "env": {        "BROWSER_EXECUTABLE": "/usr/bin/chromium-browser"      }    },    "api_service": {      "command": "python",      "args": ["-m", "mcp_server", "--port", "3001"],      "env": {        "API_KEY": "your_api_key_here",        "DEBUG": "true"      }    },    "webhook_server": {      "url": "http://localhost:3000/events"    }  }}
+```
+
+### Server configuration types​
+
+#### Command-based server​
+
+```
+{  "server_name": {    "command": "command_to_execute",    "args": ["arg1", "arg2", "arg3"],    "env": {      "ENV_VAR": "value",      "ANOTHER_VAR": "another_value"    }  }}
+```
+
+#### URL-based server​
+
+```
+{  "server_name": {    "url": "http://localhost:3000/events"  }}
+```
+
+### Scope and precedence​
+
+MCP configuration can exist in two places:
+
+1. Local scope: .mcp.json in the current project
+2. User scope: global ForgeCode config directory
+
+Local scope wins over user scope when both define the same server.
+
+> Note Find your resolved configuration path by running /info in ForgeCode Shell.
+
+### Disable a server without deleting it​
+
+Set "disable": true on a server entry.
+
+```
+{  "mcpServers": {    "github": {      "url": "https://api.githubcopilot.com/mcp/",      "disable": true    },    "weather": {      "command": "node",      "args": ["weather-server.js"],      "disable": false    }  }}
+```
+
+Behavior:
+
+- "disable": true: server is ignored and not loaded
+- "disable": false or omitted: server loads normally
+
+## How tools become available to agents​
+
+After you add a server, tool registration is automatic.
+
+```
+Add MCP server -> ForgeCode loads config -> Tools are registered -> All agents can use them
+```
+
+You do not need per-agent setup.
+
+To verify which MCP tools are available to your current agent, run:
+
+```
+:tools
+```
+
+Use this whenever you switch agents and want to confirm the active tool list.
+
+## Example setups​
+
+### Browser automation​
+
+```
+{  "mcpServers": {    "browser": {      "command": "npx",      "args": ["@modelcontextprotocol/server-browser"],      "env": {        "HEADLESS": "false",        "VIEWPORT_WIDTH": "1920",        "VIEWPORT_HEIGHT": "1080"      }    }  }}
+```
+
+Use this for UI testing, data extraction, and scripted page interactions.
+
+### External API integration​
+
+```
+{  "mcpServers": {    "weather_api": {      "command": "python",      "args": ["-m", "weather_mcp_server"],      "env": {        "WEATHER_API_KEY": "your_api_key",        "DEFAULT_LOCATION": "San Francisco"      }    }  }}
+```
+
+Use this for real-time data access and API-backed workflows.
+
+### Development tool integration​
+
+```
+{  "mcpServers": {    "database_tools": {      "command": "node",      "args": ["database-mcp-server.js"],      "env": {        "DB_CONNECTION_STRING": "postgresql://user:pass@localhost:5432/db",        "QUERY_TIMEOUT": "30000"      }    }  }}
+```
+
+Use this for database operations, schema work, and migration tooling.
+
+## Security checklist​
+
+- Store secrets in environment variables, not inline config
+- Grant minimum server permissions
+- Prefer HTTPS for URL-based servers
+- Rotate API keys and access tokens regularly
+
+## Troubleshooting​
+
+### Server connection failures​
+
+- Verify server URL and port
+- Check network reachability
+- Confirm required environment variables
+- Validate credentials and tokens
+
+### Command execution failures​
+
+- Verify command path and arguments
+- Check runtime dependencies
+- Confirm file permissions
+- Re-check environment variables
+
+### Configuration issues​
+
+- Validate .mcp.json syntax
+- Confirm local vs user scope expectations
+- Check whether the server is disabled
+- Run forge mcp list to confirm loaded servers
+
+## What to do next​
+
+Add one server you need today, verify it with forge mcp list, and use it in your next agent session. That gives you the fastest path to a real MCP workflow.

homelab/raw/articles/forge/reference/docs-model-selection-guide.md

@@ -0,0 +1,65 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/docs/model-selection-guide/
+scraped: 2026-04-28T21:02:40.747705+00:00
+content_hash: 537c47d8
+---
+# AI Model Selection Guide: Optimize ForgeCode for Your Workflow
+
+## How to Change Models in ForgeCode​
+
+Switching models is quick and intuitive:
+
+1. Open the model selector by typing :model in your ForgeCode session
+2. Browse available models using the dropdown that appears (across all logged-in providers)
+3. Search by name - just start typing the model name to filter
+4. Navigate with keyboard - use up/down arrow keys to select
+5. Press Enter to confirm your selection
+
+To log in to a new provider, use :provider-login or :login.
+
+The interface shows you model capabilities and pricing so you can make informed decisions.
+
+## Why Model Selection Matters​
+
+The model you choose dramatically impacts your development experience. Different models excel at different tasks - some are fast for simple edits, others provide deep reasoning for complex problems. ForgeCode makes switching between models effortless, so you can always use the right tool for the job.
+
+## Understanding Model Capabilities​
+
+### Speed vs. Reasoning Trade-offs​
+
+Fast Models (Sonnet, Grok-4, Gpt-4.1):
+
+- Excellent for routine code edits and simple tasks
+- Sub-second response times
+- Perfect for refactoring, formatting, and quick fixes
+- Cost-effective for high-volume usage
+
+Reasoning Models (Opus 4, O3, Deepseek-r1-0528):
+
+- Superior for complex problem-solving and architecture decisions
+- Better understanding of large codebases
+- More accurate with nuanced requirements
+- Worth the extra time for critical implementations
+
+## Pro Tips​
+
+Model Memory: Conversation context is preserved when switching models so you can continue where you left off.
+
+Experiment Freely: Model switching is instant and free - try different models to see what works best for your style.
+
+Save Preferences: ForgeCode remembers your last model choice for quick access and next time it will start with the last used model.
+
+Remember: The best model is the one that gets your job done efficiently. Start with what feels right, and don't hesitate to switch when you need different capabilities. ForgeCode makes it effortless to find the perfect AI partner for every task.
+
+---
+
+### Getting Help​
+
+If you're experiencing issues with ForgeCode:
+
+## Related Guides​
+
+- Custom Rules Guide: Extending ForgeCode's Capabilities
+- Plan and Act Guide: Automating Complex Workflows with ForgeCode

homelab/raw/articles/forge/reference/docs-operating-agents.md

@@ -0,0 +1,126 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/docs/operating-agents/
+scraped: 2026-04-28T21:02:40.384503+00:00
+content_hash: cf310963
+---
+# Agents
+
+ForgeCode provides three specialized agents, each designed for different stages of development work. They differ in capabilities and access levels, allowing you to choose the right approach for your task.
+
+## Agent Comparison​
+
+| Agent | Access | Purpose | Best For |
+|---|---|---|---|
+| muse | read + write | Planning & analysis | Reviewing impact, planning changes, critical systems |
+| forge | read + write | Implementation | Making changes, fixing bugs, creating features |
+| sage | read | Research & investigation | Understanding codebases, tracing bugs, analyzing architecture |
+
+Typical workflow: Use muse to plan → Switch to forge to implement
+
+Both agents can use sage internally to research and understand your codebase when needed.
+
+## Agent Selection Summary​
+
+Here are the key points to remember when selecting an agent:
+
+### How to switch quickly​
+
+1. Type :agent in your ForgeCode session
+2. Browse the available agents list
+3. Use ↑/↓ to choose an agent
+4. Press Enter to confirm
+
+### Why selection matters​
+
+Models control raw intelligence, while agents control behavior and execution style. Picking the right agent gives you help that matches your current stage of work.
+
+### When to switch​
+
+- Use sage for deep research and system understanding
+- Use muse for planning and change analysis
+- Use forge for direct implementation and code changes
+- Use custom agents for team- or domain-specific workflows
+
+### Pro tips​
+
+- Your conversation and project context are preserved when switching agents
+- Combine :agent with :model to tune both behavior and intelligence
+
+---
+
+## muse Agent​
+
+muse analyzes your codebase and creates detailed implementation plans. It proposes solutions and explains the impact of changes without executing them.
+
+Switch to muse: /muse
+
+Ideal for:
+
+- Planning complex refactoring
+- Understanding scope before implementation
+- Working with critical or production code
+- Learning how to implement specific features
+- Changes requiring team review
+
+Example prompts:
+
+- "How would you redesign this API for better scalability?"
+- "Create a plan to add user authentication"
+- "What's needed to implement pagination?"
+
+---
+
+## forge Agent​
+
+forge implements solutions directly. It modifies files, creates code, and executes commands to complete tasks immediately.
+
+Switch to forge: /forge (active by default)
+
+Ideal for:
+
+- Quick fixes and routine tasks
+- Refactoring with immediate results
+- Implementing approved plans
+- Tasks where you want hands-off execution
+- Creating new features
+
+Example prompts:
+
+- "Fix the null pointer exception in UserService"
+- "Create a React component for the user profile"
+- "Add unit tests for the payment processor"
+
+---
+
+## sage (Internal Research Tool)​
+
+sage is not a user-facing agent, but it's an internal tool that both muse and forge can use automatically to research and understand your codebase. When either agent needs to investigate code, trace functionality, or analyze architecture, it leverages sage behind the scenes.
+
+You don't need to manually switch to sage; it works transparently when the agents need deeper codebase insights.
+
+---
+
+## Switching Between Agents​
+
+You can switch between agents at any time during your session:
+
+- Use :muse to switch to muse Agent
+- Use :forge to switch to forge Agent
+- Use :agent to see all available agents and choose from a dropdown
+
+Common patterns:
+
+- Use muse before making significant changes to critical systems
+- Switch to forge when you're ready to implement
+- Both agents will automatically use sage for research when needed
+
+Best practice: Use version control and commit your work before using forge for significant changes.
+
+---
+
+## Related Guides​
+
+- Plan and Act Guide: Strategic AI Development Workflow with ForgeCode
+- AI Model Selection Guide: Optimize ForgeCode for Your Workflow

homelab/raw/articles/forge/reference/docs-permissions.md

@@ -0,0 +1,195 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/docs/permissions/
+scraped: 2026-04-28T21:02:25.021876+00:00
+content_hash: c5cb7af7
+---
+# permissions.yaml
+
+permissions.yaml is ForgeCode's policy file for built-in tools. It only matters when restricted mode is enabled in .forge.toml.
+
+## Start with the simplest possible example​
+
+This policy does three things:
+
+- allows reads anywhere
+- asks before writes
+- blocks rm
+
+```
+policies:  - permission: allow    rule:      read: "**/*"  - permission: confirm    rule:      write: "**/*"  - permission: deny    rule:      command: "rm*"
+```
+
+That is the whole mental model.
+
+## Turn it on​
+
+permissions.yaml does nothing until restricted mode is enabled:
+
+```
+restricted = true
+```
+
+Add that to ~/.forge/.forge.toml, or to the .forge.toml inside your custom config directory if you use FORGE_CONFIG.
+
+When restricted = false, ForgeCode behaves normally and does not gate tool execution through this policy file.
+
+## Where the file lives​
+
+ForgeCode reads the file from its config directory:
+
+- macOS/Linux: ~/.forge/permissions.yaml
+- Windows: %USERPROFILE%\\.forge\\permissions.yaml
+- Custom config directory: $FORGE_CONFIG/permissions.yaml
+
+If restricted mode is enabled and the file does not exist yet, ForgeCode creates it with a default allow-all policy.
+
+That default looks like this:
+
+```
+policies:  - permission: allow    rule:      read: "**/*"  - permission: allow    rule:      write: "**/*"  - permission: allow    rule:      command: "*"  - permission: allow    rule:      url: "*"
+```
+
+So turning on restricted mode alone does not make ForgeCode stricter. The restriction comes from the rules you write.
+
+## The shape of the file​
+
+Every file starts with one top-level key:
+
+```
+policies:  - permission: allow    rule:      read: "**/*.rs"
+```
+
+A simple policy has two parts:
+
+- permission: what should happen
+- rule: what should match
+
+### Permission values​
+
+| Value | What it means |
+|---|---|
+| allow | Run the operation immediately |
+| deny | Reject the operation immediately |
+| confirm | Pause and ask you first |
+
+### Rule types​
+
+A rule matches exactly one kind of operation:
+
+| Key | Matches | Example |
+|---|---|---|
+| read | File reads and file searches | "docs/**/*" |
+| write | Writes, patches, and deletes | "src/**/*" |
+| command | Shell command strings | "git *" |
+| url | Network fetches | "https://api.github.com/*" |
+
+You can also scope any rule to a working directory with dir:
+
+```
+- permission: allow  rule:    write: "**/*.rs"    dir: "/home/user/project/*"
+```
+
+That rule only applies when the current working directory matches the dir glob.
+
+## How ForgeCode evaluates policies​
+
+A matching allow is not always final. ForgeCode can keep scanning because a later deny or confirm may still need to stop the operation.
+
+Suppose ForgeCode wants to run git status.
+
+```
+run `git status`  -> check rules from top to bottom  -> matching deny?    stop and reject  -> matching confirm? stop and ask  -> matching allow?   remember it and keep going  -> nothing decisive matched? ask by default
+```
+
+That last line matters: no matching policy means confirm, not allow.
+
+## What ForgeCode actually checks​
+
+Built-in tools are mapped into four operation types:
+
+| Tool family | Checked as |
+|---|---|
+| Read, FsSearch | read |
+| Write, Patch, MultiPatch, Remove | write |
+| Shell | command |
+| Fetch | url |
+
+Some tools are exempt from this policy system, including SemSearch, Undo, Plan, and Task.
+
+MCP tools also bypass this file entirely. permissions.yaml governs ForgeCode's built-in tools, not external MCP integrations.
+
+## Confirmation mode​
+
+When a matching rule returns confirm — or when nothing matches and ForgeCode falls back to confirm — you get a prompt with three choices:
+
+| Choice | Result |
+|---|---|
+| Accept | Allow this one operation |
+| Reject | Deny this one operation |
+| Accept and Remember | Allow it now and append a matching rule to permissions.yaml |
+
+The remembered rule depends on what you approved:
+
+| Operation | Generated pattern |
+|---|---|
+| Read or write file.rs | *.rs |
+| Fetch https://example.com/api | example.com* |
+| Run git push origin main | git push* |
+| Run ls | ls* |
+| Read or write a file with no extension | No rule is added |
+
+This makes confirmation useful for tightening policies gradually instead of designing the whole file up front.
+
+## Logical policies​
+
+Simple rules cover most setups. When they do not, permissions.yaml also supports all, any, and not.
+
+```
+policies:  - all:      - permission: allow        rule:          read: "src/**/*"      - permission: allow        rule:          dir: "/home/user/project/*"          read: "**/*"  - any:      - permission: allow        rule:          read: "**/*.rs"      - permission: allow        rule:          read: "**/*.toml"  - not:      permission: deny      rule:        command: "rm -rf/*"
+```
+
+Use these sparingly. Most policy files are easier to reason about when each rule does one obvious thing.
+
+## Good patterns​
+
+Here are a few narrower patterns.
+
+### Allow writes only for one kind of file​
+
+```
+policies:  - permission: allow    rule:      read: "**/*"  - permission: allow    rule:      write: "**/*.rs"  - permission: deny    rule:      write: "**/*"
+```
+
+### Allow one API, deny the rest​
+
+```
+policies:  - permission: allow    rule:      url: "https://api.github.com/*"  - permission: deny    rule:      url: "*"
+```
+
+### Allow writes only inside one project directory​
+
+```
+policies:  - permission: allow    rule:      write: "**/*"      dir: "/home/user/myproject/*"  - permission: deny    rule:      write: "**/*"
+```
+
+## Common mistakes​
+
+### Turning on restricted mode and expecting instant safety​
+
+Restricted mode only enables policy evaluation. If the generated permissions.yaml still allows everything, ForgeCode still allows everything.
+
+### Forgetting the fallback behavior​
+
+If no rule matches, ForgeCode asks. That is usually what you want, but it can feel surprising if you expected silent denial.
+
+### Trying to control MCP tools here​
+
+You cannot. This file covers built-in tools only.
+
+## Where to go next​
+
+If you have not enabled restricted mode yet, start with the .forge.toml setting in the .forge.toml reference.
+
+Then come back and write the smallest policy file that matches how you actually work.

homelab/raw/articles/forge/reference/docs-plan-and-act-guide.md

@@ -0,0 +1,105 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/docs/plan-and-act-guide/
+scraped: 2026-04-28T21:02:18.556037+00:00
+content_hash: 999a0353
+---
+# Plan First, Then Act
+
+One of the biggest mistakes developers make with AI coding tools is jumping straight into implementation. After analyzing thousands of successful AI-assisted development sessions, we've learned that the most productive workflow follows a simple pattern: Plan first, then act.
+
+ForgeCode makes this workflow smooth with two specialized agents designed to work together.
+
+## Meet Your AI Development Team​
+
+### Muse Agent: Your Strategic Planner​
+
+Muse operates in read-only mode, making it perfect for analysis and planning without touching your code:
+
+- Analyzes your codebase and identifies potential issues
+- Creates detailed implementation plans
+- Explores different solution approaches
+- Reviews code for security, performance, and architecture concerns
+
+When to use Muse:
+
+- Before making significant changes to critical systems
+- When you need to understand the scope and impact of a task
+- For architecture planning.
+- When working in unfamiliar codebases
+
+### ForgeCode Agent: Your Implementation Partner​
+
+ForgeCode has full read-write access and handles the actual implementation:
+
+- Modifies files and creates new code
+- Executes commands and runs tests
+- Implements the solutions from your plan
+- Provides real-time feedback as changes are made
+
+When to use ForgeCode:
+
+- After reviewing and approving a plan from Muse
+- For routine tasks you're confident about
+- When you want hands-off implementation
+- For quick fixes with proper version control
+
+## The Plan-and-Act Workflow​
+
+Here's how successful developers use both agents together:
+
+### 1. Start with Muse for Planning​
+
+Switch to Muse from your ZSH shell:
+
+```
+:muse
+```
+
+Ask Muse to create a detailed plan:
+
+```
+: Write a plan for adding rate limiting to our API. Include:- Which endpoints need protection- Storage mechanism for rate data- Error responses and status codes- Integration points with existing middlewareNow critique this plan. What did you miss?
+```
+
+### 2. Review and Refine the Plan​
+
+Muse will provide a structured plan and then critique it for gaps. Review this carefully - a good plan eliminates most of implementation confusion later.
+
+### 3. Switch to ForgeCode for Implementation​
+
+Switch back to ForgeCode:
+
+```
+:forge
+```
+
+Reference the plan and start implementation:
+
+```
+: Following the $(@rate-limiting-plan.md) we discussed, implement the Redis-based rate limiter for the /api/auth endpoints first in $(@src/auth).
+```
+
+### 4. Iterate as Needed​
+
+Switch back to Muse if you encounter complex decisions, then return to ForgeCode for continued implementation.
+
+## Why This Works​
+
+Planning prevents confusion: When AI understands the full scope upfront, it makes better implementation decisions and avoids getting lost halfway through.
+
+Separation of concerns: Muse focuses purely on analysis without the pressure to implement, leading to better strategic thinking.
+
+Safety first: Critical systems get proper review before any changes are made.
+
+Faster iteration: Once you have a solid plan, ForgeCode can implement quickly without constant back-and-forth.
+
+## Quick Tips for Success​
+
+- Be specific in your planning requests - include edge cases, error handling, and integration points
+- Commit frequently - clean git state makes it easier to track AI changes
+- Review everything - treat AI output like a junior developer's code
+- Avoid frequent agent switching - it causes context thrashing, hurts cache performance, and creates confusing context handoffs
+
+Remember: You're the architect, Muse is your strategic advisor, and Forge is your implementation partner. Use each for what they do best.

homelab/raw/articles/forge/reference/docs-proxy-configuration.md

@@ -0,0 +1,102 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/docs/proxy-configuration/
+scraped: 2026-04-28T21:02:25.451175+00:00
+content_hash: 8f9989cc
+---
+# $HTTP_PROXY
+
+If you're behind a corporate firewall, a VPN exit node, or any network that requires outbound traffic to go through a proxy, ForgeCode respects the standard HTTP_PROXY and HTTPS_PROXY environment variables. Set them once, and every API call ForgeCode makes — to OpenAI, Anthropic, OpenRouter, or any custom provider — will flow through your proxy.
+
+## Setting the Proxy​
+
+ForgeCode reads two standard environment variables:
+
+| Environment Variable | Protocol | Example Value |
+|---|---|---|
+| HTTP_PROXY | HTTP | http://proxy.company.com:8080 |
+| HTTPS_PROXY | HTTPS | http://proxy.company.com:8080 |
+| NO_PROXY | — | localhost,127.0.0.1,.internal.io |
+
+Both HTTP_PROXY and HTTPS_PROXY accept an HTTP proxy URL — even for HTTPS traffic. The connection to the target server is tunneled through the proxy using the CONNECT method, so the proxy itself doesn't see the encrypted payload.
+
+There are three ways to set them, depending on how permanent you want the configuration to be.
+
+~/.env — persistent, ForgeCode-only
+
+The .env file in your home directory is loaded by ForgeCode on every run. This is the right choice when you want the proxy active for ForgeCode without affecting other tools on your system:
+
+```
+# ~/.envHTTP_PROXY=http://proxy.company.com:8080HTTPS_PROXY=http://proxy.company.com:8080NO_PROXY=localhost,127.0.0.1,.internal.company.com
+```
+
+~/.zshrc (or ~/.bashrc) — persistent, system-wide
+
+Adding the variables to your shell profile makes them available to every process in your terminal, not just ForgeCode. Use this when all outbound tools on your machine need to go through the proxy:
+
+```
+# ~/.zshrcexport HTTP_PROXY=http://proxy.company.com:8080export HTTPS_PROXY=http://proxy.company.com:8080export NO_PROXY=localhost,127.0.0.1,.internal.company.com
+```
+
+Reload your shell after editing (source ~/.zshrc) or open a new terminal.
+
+Current session — temporary
+
+To route traffic through a proxy only for the duration of your current terminal session:
+
+```
+export HTTP_PROXY=http://proxy.company.com:8080export HTTPS_PROXY=http://proxy.company.com:8080
+```
+
+The variables are gone when the session ends.
+
+## Authenticated Proxies​
+
+If your proxy requires a username and password, embed the credentials in the URL:
+
+```
+HTTP_PROXY=http://username:password@proxy.company.com:8080HTTPS_PROXY=http://username:password@proxy.company.com:8080
+```
+
+Proxy credentials embedded in URLs can appear in shell history, process listings, and log files. Prefer storing them in your ~/.env file with restricted permissions (chmod 600 ~/.env) rather than exporting them directly in your terminal.
+
+## How Traffic Flows​
+
+ForgeCode makes HTTPS requests to AI provider APIs. When HTTPS_PROXY is set, the flow looks like this:
+
+```
+ForgeCode    |    | CONNECT api.openai.com:443    vProxy Server (proxy.company.com:8080)    |    | Tunnels encrypted TLS connection    vAI Provider API (api.openai.com)
+```
+
+The proxy only sees that a tunnel is being opened — the TLS handshake and all request/response content remain encrypted end-to-end between ForgeCode and the AI provider.
+
+## Bypassing the Proxy for Specific Hosts​
+
+NO_PROXY accepts a comma-separated list of hostnames, IP addresses, and domain suffixes that should bypass the proxy:
+
+```
+# Bypass proxy for localhost, a specific IP, and anything under .internal.company.comNO_PROXY=localhost,127.0.0.1,192.168.1.0/24,.internal.company.com
+```
+
+Leading dots (.internal.company.com) match any subdomain of that domain.
+
+## Proxy with Custom Certificates​
+
+Corporate proxies commonly perform TLS inspection — they intercept HTTPS connections, decrypt them, inspect the traffic, and re-encrypt using their own certificate authority. If ForgeCode fails to connect with certificate errors, your proxy is likely doing this.
+
+The fix is to add your corporate CA certificate to ForgeCode's trusted roots:
+
+```
+# ~/.envHTTPS_PROXY=http://proxy.company.com:8080# Trust the corporate CA that signs the proxy's certificatesFORGE_HTTP__ROOT_CERT_PATHS=/etc/ssl/certs/corporate-ca.pem
+```
+
+ForgeCode accepts certificates in PEM, CRT, or CER format. For multiple certificates, provide a comma-separated list of paths.
+
+If you cannot obtain the CA certificate and need to connect urgently in a controlled environment:
+
+```
+FORGE_HTTP__ACCEPT_INVALID_CERTS=true
+```
+
+FORGE_HTTP_ACCEPT_INVALID_CERTS=true disables all certificate validation. This removes protection against man-in-the-middle attacks. Only use it in isolated development environments where you control the network — never in production or on untrusted networks.

homelab/raw/articles/forge/reference/docs-shortcuts.md

@@ -0,0 +1,78 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/docs/shortcuts/
+scraped: 2026-04-28T21:02:37.614869+00:00
+content_hash: 241ba0ba
+---
+# Shortcuts
+
+These shortcuts are built into ZSH — ForgeCode doesn't add or modify them. They work in any ZSH session, not just when using ForgeCode.
+
+ZSH uses Emacs keybindings by default. If you prefer Vi mode, add bindkey -v to your ~/.zshrc.
+
+Run forge zsh keyboard at any time to print this reference in your terminal. For the full reference, see the official ZSH Line Editor documentation.
+
+## Navigation​
+
+| Shortcut | Action |
+|---|---|
+| Ctrl+A | Move to beginning of line |
+| Ctrl+E | Move to end of line |
+| Option+F | Move forward one word |
+| Option+B | Move backward one word |
+
+## Editing​
+
+| Shortcut | Action |
+|---|---|
+| Ctrl+U | Kill line before cursor |
+| Ctrl+K | Kill line after cursor |
+| Ctrl+W | Kill word before cursor |
+| Option+D | Kill word after cursor |
+| Ctrl+Y | Yank (paste) killed text |
+| Ctrl+_ | Undo last edit |
+
+## History​
+
+| Shortcut | Action |
+|---|---|
+| Ctrl+R | Search command history backward |
+| Ctrl+S | Search command history forward |
+| Ctrl+P / ↑ | Previous command |
+| Ctrl+N / ↓ | Next command |
+| Option+< | Move to first history entry |
+| Option+> | Move to last history entry |
+
+## Other​
+
+| Shortcut | Action |
+|---|---|
+| Ctrl+L | Clear screen |
+| Ctrl+C | Cancel current command |
+| Ctrl+Z | Suspend current command |
+| Tab | Complete command/path |
+
+If Option key shortcuts aren't working, run forge zsh doctor — the most common cause is a terminal that isn't passing the Option key through correctly.
+
+## Reference​
+
+ZSH exposes the full set of bindings and editor actions directly from the shell.
+
+List all current key bindings:
+
+```
+bindkey
+```
+
+List all available editor actions:
+
+```
+zle -al
+```
+
+List bindings for a specific keymap (e.g. Emacs):
+
+```
+bindkey -M emacs
+```

homelab/raw/articles/forge/reference/docs-skills.md

@@ -0,0 +1,56 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/docs/skills/
+scraped: 2026-04-28T21:02:23.680487+00:00
+content_hash: 5f2e8076
+---
+# SKILL.md
+
+Skills are reusable workflows you teach ForgeCode once. Write the process down in a SKILL.md file and place any supporting scripts, examples, or other resources alongside it — ForgeCode will automatically load the right skill whenever the task calls for it.
+
+## Getting Started​
+
+Skills can live in three places:
+
+- Project skills — .forge/skills/<skill-name>/SKILL.md inside your project, checked into version control and shared with your team.
+- Agents skills — ~/.agents/skills/<skill-name>/SKILL.md on your machine, shared with any agent tool that follows the common agents convention.
+- Global skills — ~/forge/skills/<skill-name>/SKILL.md on your machine, available across every project you work on.
+
+Each skill is a plain markdown file — write it the same way you'd explain the process to a new teammate.
+
+```
+.forge/                          # project skills (highest precedence)└── skills/    └── release-notes/        └── SKILL.md~/.agents/                       # agents skills (shared across agent tools)└── skills/    └── release-notes/        └── SKILL.md~/forge/                         # global skills (all projects)└── skills/    └── release-notes/        └── SKILL.md
+```
+
+When multiple sources define a skill with the same name, the one with higher precedence wins: project > agents > global > built-in.
+
+Here's what a release notes skill looks like:
+
+```
+# Generate Release Notes1. Run `./scripts/get-commits.sh` to collect commits since the last tag2. Run `./scripts/categorize.sh` to group them into Features, Bug Fixes, and Breaking Changes3. Write the release notes in `CHANGELOG.md` using the output from the scripts4. Run `./scripts/validate-changelog.sh` to confirm the format is correct
+```
+
+ForgeCode reads all skills at the start of a session and automatically applies the relevant one based on what you're asking it to do — no need to invoke them by name.
+
+The easiest way to create a skill is to ask ForgeCode directly. Describe the workflow — the steps, scripts, and edge cases — and it will generate the SKILL.md in the right place:
+
+```
+Create a release-notes skill. It should collect all commits since the last tag,group them by type — Features, Bug Fixes, Breaking Changes — write the notes tothe changelog, and run a validation check at the end.
+```
+
+Review the generated file, adjust anything that doesn't match your setup, and it's ready to use. The more detail you give, the better the skill.
+
+## Importing Claude Code Skills​
+
+Skills are fully compatible with Claude Code. The SKILL.md format is identical — no conversion needed.
+
+They work without any changes.
+
+## Verifying Your Skills​
+
+To confirm ForgeCode has picked up your skills, run :skill in the chat. You'll see a list of all available skills along with their descriptions.
+
+```
+:skill
+```

homelab/raw/articles/forge/reference/docs-vscode-extension.md

@@ -0,0 +1,278 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/docs/vscode-extension/
+scraped: 2026-04-28T21:02:29.527059+00:00
+content_hash: d2870143
+---
+# VS Code Extension
+
+Tired of manually typing file paths and copying code snippets when asking ForgeCode for help? This VS Code extension lets you reference any code with a single keystroke and start ForgeCode sessions directly from your editor.
+
+## What This Extension Does​
+
+The problem: Describing code problems is slow and unclear
+
+- "That function around line 50 something..."
+- Copy-pasting code snippets manually
+- Typing out long file paths
+
+The solution: Show ForgeCode exactly what you mean
+
+- Select any code → Press Ctrl+U → Get a perfect reference
+- Works with single lines, code blocks, or entire files
+
+This extension works with ForgeCode CLI. Install that first if you haven't already.
+
+## See It in Action​
+
+What you just saw: Select code → Press Ctrl+U → Reference copied and ready to use with ForgeCode.
+
+## Installation​
+
+### What You Need​
+
+- VS Code: Version 1.102.0 or higher
+- ForgeCode CLI: Install it first if you haven't already
+
+### Install the Extension​
+
+Option 1: VS Code Marketplace (Recommended)
+
+1. Open VS Code
+2. Press Ctrl+Shift+X to open Extensions panel
+3. Search for "ForgeCode"
+4. Click Install on the official ForgeCode extension
+
+Option 2: Command Line
+
+```
+code --install-extension ForgeCode.forge-vscode
+```
+
+Test that it works: Open any code file, select some text, press Ctrl+U. If a file reference gets copied to your clipboard, you're ready to go!
+
+Official extension: VS Code Marketplace
+
+## Basic Usage​
+
+### The Core Workflow​
+
+1. Select code (or don't select anything for whole file)
+2. Press Ctrl+U
+3. Paste into ForgeCode conversation
+
+That's it. No typing, no manual copying.
+
+What gets copied:
+
+Format: @[<filepath>:<line start>:<line end>]
+
+How selection works:
+
+- No selection: @[path/to/file.js] → References entire file
+- Single line: @[path/to/file.js:42:42] → References line 42 only
+- Multiple lines: @[path/to/file.js:15:28] → References lines 15-28
+
+### Power Move: Multi-File References​
+
+Here's the real power move. You can reference multiple files in a single ForgeCode prompt by copying and pasting references one at a time:
+
+Example:
+
+```
+: Compare these approaches @[src/utils/oldMethod.js:15:45] @[src/utils/newMethod.js:20:50]: Review this component and its styles @[components/Button.tsx] @[styles/button.css:12:34]
+```
+
+Now ForgeCode can see exactly what code you're talking about, with full context and precise line numbers. No more "that function around line 50 something" conversations.
+
+Alternative ways to copy:
+
+- Command Palette: Ctrl+Shift+P → type "Copy File Reference"
+- Right-click Menu: Select code → right-click → "Copy File Reference"
+
+### Start New ForgeCode Session​
+
+Start a ForgeCode terminal directly in VS Code without switching windows.
+
+How to use:
+
+- Command Palette: Ctrl+Shift+P → type "Start New ForgeCode Session"
+- Right-click Menu: Right-click in any file → "Start New ForgeCode Session"
+- Editor Toolbar: Click the ForgeCode icon in the top-right of the editor
+
+The extension will:
+
+1. Create a new integrated terminal in VS Code
+2. Navigate to your workspace directory
+3. Start ForgeCode automatically
+4. Auto-paste any file reference from the current editor (if open)
+
+## Real-World Examples​
+
+### Debugging Issues​
+
+Scenario: Authentication fails in production but works locally.
+
+```
+: Help me debug this auth function @[src/auth/AuthService.ts:45:67] - works locally but fails in production
+```
+
+ForgeCode sees the exact code and can suggest environment-specific issues to check.
+
+### Code Reviews​
+
+Scenario: You spot a component that could be improved.
+
+```
+: Can you refactor this component to use hooks? @[components/UserProfile.tsx:12:89] Also suggest performance optimizations
+```
+
+Instead of generic advice, ForgeCode sees your specific component and suggests targeted improvements.
+
+### Type Mismatches​
+
+Scenario: API data doesn't match your TypeScript types.
+
+```
+: @[src/api/users.js:156:203] @[src/types/User.ts] have a type mismatch - API returns 'user_id' but type expects 'userId'
+```
+
+ForgeCode compares both files simultaneously and suggests proper fixes.
+
+### Feature Implementation​
+
+Scenario: Adding dark mode across multiple components.
+
+```
+: Add dark mode support to @[src/components/ThemeProvider.tsx:15:45] and update @[src/styles/theme.css:23:67]
+```
+
+ForgeCode understands your theme system and suggests consistent changes across files.
+
+## Configuration​
+
+The extension provides several settings to customize its behavior. Access settings via File → Preferences → Settings → Extensions → ForgeCode.
+
+### Available Settings​
+
+#### forge.terminalMode​
+
+Controls terminal interaction when copying file references with Ctrl+U.
+
+- Type: String (dropdown)
+- Options: once (default): Open terminal once and reuse it for subsequent operations never: Never open terminal, only copy file reference to clipboard
+- once (default): Open terminal once and reuse it for subsequent operations
+- never: Never open terminal, only copy file reference to clipboard
+
+- Default: once
+
+When to use once: Most users should use this. The extension intelligently manages ForgeCode terminals, creating one when needed and reusing it for subsequent file references.
+
+When to use never: Use this if you always work with ForgeCode in an external terminal and only want the extension to copy file references to clipboard without any terminal interaction.
+
+#### forge.pasteDelay​
+
+Delay in milliseconds before auto-pasting file reference into a newly created ForgeCode terminal.
+
+- Type: Number
+- Default: 5000 (5 seconds)
+- Range: 0-10000 milliseconds
+
+Why this exists: When the extension creates a new ForgeCode terminal, it needs time to start up before accepting input. This delay ensures the file reference is pasted after ForgeCode is ready.
+
+When to adjust:
+
+- If file references aren't being pasted: Increase the value (try 7000-10000ms)
+- If you have a fast machine and want quicker pasting: Decrease the value (try 3000-4000ms)
+- Note: This only affects newly created terminals, not existing ones
+
+#### forge.showInstallationPrompt​
+
+Show a prompt to install ForgeCode CLI if it's not detected in your PATH.
+
+- Type: Boolean
+- Default: true
+
+When to disable: If you use ForgeCode via npx or have it installed in a non-standard location, you might want to disable this prompt.
+
+## Troubleshooting​
+
+### Extension Not Working​
+
+Quick fixes to try:
+
+1. Verify ForgeCode CLI is installed - run forge --version in terminal
+2. Check your VS Code version (Help → About) - need 1.102.0+
+3. Verify the extension is enabled in Extensions view (Ctrl+Shift+X)
+4. Restart VS Code completely
+
+### Keyboard Shortcut Not Working​
+
+Ctrl+U does nothing:
+
+This usually means another extension grabbed that shortcut. Here's how to fix it:
+
+1. File → Preferences → Keyboard Shortcuts
+2. Search for "ForgeCode" or "Copy File Reference"
+3. Click the pencil icon next to "Copy File Reference"
+4. Pick a new combo like Ctrl+Shift+U or Alt+U
+
+Common culprits: Vim extensions, browser preview extensions, other developer tools.
+
+### Nothing Gets Copied to Clipboard​
+
+Try these workarounds:
+
+- Use Command Palette: Ctrl+Shift+P → "Copy File Reference"
+- Use right-click menu → "Copy File Reference"
+- Check if you're in a text file (extension won't work on images/binaries)
+- Some systems have clipboard permission issues - restart VS Code usually fixes this
+
+### Terminal Not Opening or ForgeCode Not Starting​
+
+If "Start New ForgeCode Session" doesn't work:
+
+1. Check that ForgeCode is in your PATH - run which forge (macOS/Linux) or where forge (Windows) in terminal
+2. Verify ForgeCode is installed by running forge --version
+3. Restart VS Code after installing ForgeCode
+
+If file references aren't being pasted automatically:
+
+- Increase the forge.pasteDelay setting (try 7000-10000ms for slower machines)
+- The default is 5000ms (5 seconds) - if that's not enough, ForgeCode may need more time to start
+- Check that your terminal shell is compatible (bash, zsh, PowerShell work well)
+- Try using Ctrl+U to copy the reference, then manually paste it into the ForgeCode terminal
+
+### Weird File Paths​
+
+Sometimes you'll see paths like /workspaces/project/src/file.js instead of normal ones.
+
+This is actually fine. VS Code uses different path formats for remote development, containers, and workspace setups. ForgeCode handles these correctly, so don't worry about how they look.
+
+## Pro Tips​
+
+Start small: Reference one function, ask ForgeCode about it, see how it responds. Then level up to multi-file references.
+
+Be selective: Don't dump entire files unless you actually need context from the whole thing. ForgeCode works better with focused references.
+
+Combine with descriptions: @[component.tsx:45:67] this validation logic isn't working with empty strings gives ForgeCode both code and context.
+
+## Next Steps​
+
+You're ready to start using the extension! The goal isn't to reference every line of code - it's to give ForgeCode just enough context to actually help with your specific situation.
+
+## Related Guides​
+
+- File Tagging
+- Quickstart: Get started with ForgeCode in minutes
+
+---
+
+## Still Need Help?​
+
+If you're still stuck:
+
+- Extension logs: View → Output → Select "ForgeCode" from dropdown
+- Report bugs: GitHub Issues
+- Community help: Join our Discord for quick answers

homelab/raw/articles/forge/reference/docs-zsh-support.md

@@ -0,0 +1,171 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/docs/zsh-support/
+scraped: 2026-04-28T21:02:44.582641+00:00
+content_hash: b4527bec
+---
+# ZSH Support
+
+ForgeCode's interactive mode runs in its own environment. That means your ZSH aliases, custom functions, and shell tooling don't work inside it. You're stuck choosing between AI help and your own productivity setup.
+
+The : sentinel character solves this. It lets you send prompts to ForgeCode from your native ZSH session — no environment switch, no lost context, no broken aliases.
+
+```
+# Your aliases work as usual (gst = git status, gcam = git commit -am)gstgcam "fix: resolve memory leak"# Ask ForgeCode without leaving your shell: analyze the memory usage patterns in src/server.rs# Run your tools as part of the investigationps aux | grep serverhtop -p $(pgrep server)# Continue with full context: now optimize the memory allocations you identified in the server struct
+```
+
+Shell commands and AI prompts live in the same workflow. Context carries across both.
+
+`TAB`
+`:`
+Type : then immediately press TAB to open the command completion list — switch agents, start a new conversation, open the editor, and more.
+
+```
+:<TAB>   # opens the full command list
+```
+
+## Examples​
+
+### Basic Prompts​
+
+```
+: explain this error message: refactor this function to be more readable: add error handling to the database connection
+```
+
+Prompts go to your last-used agent. If this is your first interaction, it defaults to ForgeCode. The conversation continues across prompts until you run :new.
+
+### Agent Selection​
+
+Switch agents by prefixing the agent name after ::
+
+```
+:sage
+```
+
+ForgeCode prints a confirmation and updates your terminal's right-hand prompt (RPROMPT):
+
+```
+⏺ [16:14:54] SAGE is now the active agent
+```
+
+All subsequent bare : prompts now go to sage:
+
+```
+: explain the algorithm complexity and performance characteristics: what are the potential edge cases?
+```
+
+You can also pass a prompt inline as a shortcut — this switches the agent and sends the prompt in one step:
+
+```
+:forge refactor this function to be more maintainable
+```
+
+Run :agent to pick from a list of all configured agents.
+
+### Starting a New Conversation​
+
+ForgeCode carries conversation context forward indefinitely within a session, until a terminal window is closed. When you move to a different task and don't want the previous context bleeding in, run :new:
+
+```
+:new
+```
+
+This clears the conversation history and starts fresh. The active agent stays the same.
+
+You can also pass a prompt directly — :new starts the fresh conversation and sends it in one step:
+
+```
+:new hi what's the time
+```
+
+### Switching Conversations​
+
+To switch to a different existing conversation, run :conversation:
+
+```
+:conversation
+```
+
+This opens a list of your saved conversations. Select one to switch to it.
+
+To jump back to the last conversation you were in, use the - shorthand:
+
+```
+:conversation -
+```
+
+### File Tagging​
+
+Tag files in your prompts with @ followed by a partial name, then press TAB:
+
+```
+: review the changes in @package<TAB>: explain the logic in @src/utils/helper<TAB>: optimize the queries in @database/queries<TAB>
+```
+
+`TAB`
+`@`
+After typing @ and a few characters, press TAB to open a fuzzy file picker. Type to filter, arrow keys to navigate, Enter to select. The full file path is inserted into your prompt automatically. .gitignore is respected.
+
+If fd and fzf aren't installed, use the full path directly:
+
+```
+: review the changes in @[src/components/Header.tsx]
+```
+
+### Multiline Text​
+
+When your prompt needs structure (lists, steps, logs), insert line breaks directly in the prompt composer:
+
+- Windows/Linux: Shift+Enter
+- macOS: Option+Enter
+
+This lets you write multiline prompts without sending early.
+
+See Keyboard Shortcuts for all shortcuts available in your ZSH session.
+
+### :edit as an Alternative​
+
+For longer prompts, use :edit instead of typing everything inline:
+
+```
+:edit
+```
+
+This opens your configured editor from $FORGE_EDITOR or $EDITOR. Write your prompt, save, and close the editor to send it.
+
+Example (VS Code):
+
+```
+export FORGE_EDITOR="code --wait"# or: export EDITOR="code --wait"
+```
+
+### Retrying a Request​
+
+If you cancel a prompt mid-flight with Ctrl+C and want to run it again, use :retry:
+
+```
+:retry
+```
+
+This resends the last request without you having to retype it. Most useful after an accidental interrupt or a timeout.
+
+### Editing Configuration​
+
+To open the ForgeCode configuration file (~/.forge/.forge.toml) in your default editor, run :config:
+
+```
+:config-edit
+```
+
+See the configuration reference for a full list of available settings.
+
+## Troubleshooting​
+
+Start with these two commands — they cover most issues:
+
+```
+forge zsh doctor # checks your environment and reports problemsforge zsh setup  # re-runs the ZSH integration setup
+```
+
+If both run cleanly and things still aren't working, join us on Discord and we'll help you sort it out.

homelab/raw/articles/forge/reference/docs.md

@@ -0,0 +1,106 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/docs/
+scraped: 2026-04-28T21:02:33.702132+00:00
+content_hash: 58b4bfb7
+---
+# Installation & Setup
+
+ForgeCode is a CLI-based coding harness — think Claude Code, but with first-class support for many AI providers. It works equally well with cloud models, open-weight models, and models running locally.
+
+## Prerequisites​
+
+- A Nerd Font installed and enabled in your terminal (for example, FiraCode Nerd Font)
+- Zsh installed and configured
+
+## Installation​
+
+### Step 1. Install the ForgeCode binary​
+
+```
+curl -fsSL https://forgecode.dev/cli | sh
+```
+
+This works on macOS, Linux, Android, and Windows via WSL or Git Bash.
+
+Verify the installation:
+
+```
+forge --help
+```
+
+### Step 2. Configure the Zsh plugin​
+
+ForgeCode integrates with Zsh to let you send prompts directly from your shell prompt. Run the setup wizard:
+
+```
+forge zsh setup
+```
+
+Follow the interactive prompts. Once complete, you must restart your terminal for the plugin to take effect. Open a new terminal window, or reload the current session:
+
+```
+exec zsh
+```
+
+The Zsh plugin will not be active until you restart your terminal. If the : prompt trigger isn't working, this is the most common cause.
+
+If you're still having trouble, run the diagnostics command:
+
+```
+forge zsh doctor
+```
+
+This checks your environment and reports any configuration issues with the Zsh plugin.
+
+### Step 3. Log in to an AI provider​
+
+ForgeCode needs access to at least one AI model. Run:
+
+```
+:login
+```
+
+This walks you through selecting a provider and entering your API key.
+
+If you already have a ChatGPT Plus or Claude subscription, select the corresponding provider (OpenAI or Anthropic) and use that subscription's API access instead of buying a separate key.
+
+- OpenRouter — one key, 300+ models from every major vendor
+- OpenAI — GPT Codex series
+- Anthropic — Claude Sonnet and Opus series
+
+- Proprietary: Claude Sonnet & Opus series, GPT Codex series
+- Open-source: GLM, Kimi, Minimax
+
+After logging in, pick a model:
+
+```
+:model
+```
+
+Browse the list, type to filter, and press Enter. ForgeCode remembers your choice across sessions. You can change it anytime.
+
+### Step 4. Send your first prompt​
+
+With the Zsh plugin active and the LLM provider set up, type : followed by a space and your prompt:
+
+```
+: Hi! What is the time?
+```
+
+ForgeCode takes it from there.
+
+### Step 5. Explore available commands​
+
+To see all available ForgeCode commands, type : and press Tab (without space):
+
+```
+: # then press Tab WITHOUT space
+```
+
+This lists every command you can run directly from your shell.
+
+## Next Steps​
+
+Once you're set up, enable ForgeCode Services for enhanced codebase understanding, tool-call guardrails, and a semantic search engine — no API key required.

homelab/raw/articles/forge/reference/index.md

@@ -0,0 +1,16 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/
+scraped: 2026-04-28T21:02:17.849857+00:00
+content_hash: 215f8867
+---
+# World's #1 Coding Harness
+
+ForgeCode is the world’s top-ranked coding harness, leading TermBench 2.0 and setting a new state of the art.
+
+```
+curl -fsSL https://forgecode.dev/cli | sh
+```
+
+[Setup ZSH](https://forgecode.dev/docs/)

homelab/raw/articles/forge/reference/privacy.md

@@ -0,0 +1,174 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/privacy/
+scraped: 2026-04-28T21:02:38.852147+00:00
+content_hash: 936cf35a
+---
+# Privacy Policy
+
+## 1. Purpose and Scope of this Privacy Policy​
+
+ForgeCode ("we", "us" or "our") provides this Privacy Policy to inform you of our policies and procedures regarding the collection, processing and disclosure of information about you, and what rights you have with respect to your information.
+
+This Privacy Policy describes our practices regarding personal data we collect from users of our publicly available website located at https://forgecode.dev as well as any other pages that link to this Privacy Policy (the "Sites"), and in connection with our Command Line Interface tool ("ForgeCode") and related services (collectively, the "Services"). We use the terms "personal data" and "personal information" interchangeably to mean information that identifies or reasonably identifies an individual.
+
+If you reside in California, please also see our California-Specific Disclosures at Section 9 below. If you are located in the European Economic Area (EEA) or United Kingdom (UK), please also see our EEA- and UK-Specific Disclosures at Section 10 below.
+
+## 2. Information Collection​
+
+### 2.1 Information You Provide to Us​
+
+In the course of using our Sites and Services you may provide us with certain information about you, such as when you:
+
+- Create an account or register for the Services
+- Use the ForgeCode CLI
+- Participate in any interactive features of the Sites
+- Fill out a form
+- Subscribe to our newsletter or documentation updates
+- Request technical support
+- Otherwise communicate with us
+
+The types of information we may collect include:
+
+- Name
+- Email address
+- GitHub username
+- Company name (if applicable)
+- Job title (if applicable)
+- Technical information related to your use of ForgeCode CLI
+
+### 2.2 Automatically Collected Information​
+
+When you access or use our Sites and Services, we automatically collect information about you, including:
+
+Log Information:
+
+- Type of browser you use
+- Access times
+- Pages viewed
+- Browser type
+- IP address
+- Pages visited before navigating to our Services
+
+CLI Usage Information:
+
+- Command usage patterns
+- Error logs
+- Performance metrics
+- Configuration settings
+- Operating system information
+
+Device Information:
+
+- Computer or device type
+- Operating system and version
+- Unique device identifiers
+- Network information
+
+Information Collected by Cookies and Other Tracking Technologies: We use cookies and other technologies, such as web beacons, web storage, and unique advertising identifiers, to collect information about your activity, browser, and device. For more information about cookies and how to disable them, please see our Cookie Policy.
+
+### 2.3 Information We Collect from Other Sources​
+
+We may obtain information from other sources and combine that with information we collect through our Sites and Services, such as:
+
+- Information from GitHub or other third-party authentication services
+- Publicly available information from open source repositories
+- Information from third-party services that integrate with our Services
+
+## 3. Use of Information​
+
+We use information we collect about you to:
+
+- Provide, maintain, and improve our Sites and Services
+- Process and complete transactions
+- Send technical notices and support communications
+- Respond to your comments and questions
+- Send you technical updates about the ForgeCode AI assistant
+- Communicate about products, services, offers, and events
+- Monitor and analyze trends, usage, and activities
+- Detect, investigate and prevent security incidents
+- Debug to identify and repair errors
+- Conduct research and development
+- Personalize your experience
+- Protect our legal rights and prevent misuse
+- Comply with legal obligations
+
+## 4. Information Sharing​
+
+We may share information about you as follows:
+
+- With vendors, service providers, and consultants who need access to such information to carry out work on our behalf
+- In response to a request for information if required by applicable law or legal process
+- If we believe your actions are inconsistent with our user agreements or policies
+- In connection with, or during negotiations of, any merger, sale of company assets, financing or acquisition
+- Between and among our current and future parents, affiliates, subsidiaries and other companies under common control and ownership, with your consent or at your direction
+
+## 5. Data Security​
+
+We take reasonable measures to help protect information about you from loss, theft, misuse and unauthorized access, disclosure, alteration and destruction. The ForgeCode AI Shell CLI employs industry standard security practices and all sensitive data is encrypted in transit.
+
+## 6. Data Retention​
+
+We store the information we collect about you for as long as is necessary for the purpose(s) for which we originally collected it. We may retain certain information for legitimate business purposes or as required by law.
+
+## 7. International Data Transfers​
+
+We may transfer, process, and store information about you outside your home country, including in the United States, where data protection laws may not be as comprehensive as those in your country. We take appropriate safeguards to ensure that your personal information is properly protected.
+
+## 8. Your Choices​
+
+### 8.1 Account Information​
+
+You may update, correct or delete certain account information at any time by contacting us. Note that we may retain certain information as required by law or for legitimate business purposes.
+
+### 8.2 Cookies​
+
+Most web browsers are set to accept cookies by default. You can usually modify your browser settings to remove or reject browser cookies. Please note that removing or rejecting cookies could affect the availability and functionality of our Sites.
+
+### 8.3 CLI Data Collection​
+
+You can opt out of non-essential data collection in the ForgeCode AI Shell by modifying your configuration settings. Essential operational data may still be collected for security and functionality purposes.
+
+### 8.4 Communications​
+
+You may opt out of receiving promotional communications from us by following the instructions in those messages or by contacting us. If you opt out, we may still send you non-promotional communications, such as those about your account or our ongoing business relations.
+
+## 9. California-Specific Disclosures​
+
+If you are a California resident, you have additional rights under the California Consumer Privacy Act (CCPA), including:
+
+- The right to know what personal information we collect and how we use it
+- The right to delete your personal information
+- The right to opt-out of the sale of your personal information
+- The right to non-discrimination for exercising your privacy rights
+
+We do not sell personal information of California residents.
+
+## 10. EEA- and UK-Specific Disclosures​
+
+If you are located in the EEA or UK, you have certain rights under the General Data Protection Regulation (GDPR), including:
+
+- The right to access your personal data
+- The right to rectify inaccurate personal data
+- The right to delete your personal data
+- The right to restrict processing
+- The right to data portability
+- The right to object to processing
+- The right to withdraw consent
+
+## 11. Children's Privacy​
+
+Our Services are not directed to children under 13 (or other age as required by local law). We do not knowingly collect personal information from children. If you learn that a child has provided us with personal information in violation of this Privacy Policy, please contact us.
+
+## 12. Changes to this Privacy Policy​
+
+We may change this Privacy Policy from time to time. If we make changes, we will notify you by revising the date at the top of the policy and, in some cases, provide you with additional notice. Your continued use of our Services after any changes indicates your acceptance of the updated Privacy Policy.
+
+## 13. Contact Us​
+
+If you have any questions about this Privacy Policy or our privacy practices, please contact us at:
+
+Email: support@tailcall.run
+
+Website: https://forgecode.dev

homelab/raw/articles/forge/reference/releases-2025-April.md

@@ -0,0 +1,379 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/releases/2025/April/
+scraped: 2026-04-28T21:02:27.643593+00:00
+content_hash: 5608cd73
+---
+# April
+
+Update to latest version !!
+Get the instructions from the docs
+[Get Started](https://forgecode.dev/docs/)
+## v0.79.3​
+
+### 🐛 Bug Fixes​
+
+- fix(markdown): update color settings for inline code style in MarkdownFormat @tusharmath (#718)
+
+---
+
+## v0.79.2​
+
+- fix(ui): enhance model selection help message for better user guidance @tusharmath (#714)
+
+---
+
+## v0.79.1​
+
+### 🧰 Maintenance​
+
+- feat(model): model selection is mandatory and persisted after startup @tusharmath (#709)
+
+---
+
+## v0.79.0​
+
+### 🚀 Features​
+
+- feat(fs): support reading file ranges @tusharmath (#706)
+
+---
+
+## v0.78.6​
+
+- fix: custom rules optional in plan mode @amitksingh1490 (#705)
+
+---
+
+## v0.78.5​
+
+- No changes
+
+---
+
+## v0.78.4​
+
+- fix(agent): disable tool support for software engineer and designer agents @tusharmath (#702)
+
+---
+
+## v0.78.3​
+
+- fix(software-designer): restrict agent to plan creation only @tusharmath (#700)
+
+---
+
+## v0.78.2​
+
+- fix(template): improve implementation plan md format for clarity and consistency @tusharmath (#699)
+
+---
+
+## v0.78.1​
+
+- fix(orchestrator): improve handling of interrupted tool responses @tusharmath (#698)
+
+---
+
+## v0.78.0​
+
+- feat: implement dedicated planner mode with multi-agent architecture @tusharmath (#695)
+
+---
+
+## v0.77.0​
+
+- feat(title): add timestamp handling to TitleFormat and update dependencies @tusharmath (#688)
+
+---
+
+## v0.76.1​
+
+- fix(template): template rendering error @tusharmath (#693)
+
+---
+
+## v0.76.0​
+
+- fix: refactor string formatting to use new syntax @amitksingh1490 (#692)
+
+- fix: refactor string formatting to use new syntax @amitksingh1490 (#692)
+
+- fix: refactor string formatting to use new syntax @amitksingh1490 (#692)
+- refactor: Simplify ForgeTemplateService @ssddOnTop (#689)
+
+---
+
+## v0.75.0​
+
+- fix(loader): ensure explicit workflow files are merged with default @tusharmath (#690)
+
+- fix(loader): ensure explicit workflow files are merged with default @tusharmath (#690)
+
+- fix(loader): ensure explicit workflow files are merged with default @tusharmath (#690)
+
+---
+
+## v0.74.1​
+
+- No changes
+
+---
+
+## v0.74.0​
+
+- feat(display): add plain text diff output to patch tool @tusharmath (#684)
+
+- feat(display): add plain text diff output to patch tool @tusharmath (#684)
+
+---
+
+## v0.73.0​
+
+- feat(cli): enhance command output and refactor formatting @tusharmath (#682)
+
+---
+
+## v0.72.1​
+
+- feat: support models without native tool call capabilities @tusharmath (#681)
+
+---
+
+## v0.72.0​
+
+- feat: enhance chat response handling with progress indication @amitksingh1490 (#677)
+
+---
+
+## v0.71.0​
+
+- feat: improve the /help and /info commands @tusharmath (#680)
+
+- feat: improve the /help and /info commands @tusharmath (#680)
+
+- feat: improve the /help and /info commands @tusharmath (#680)
+
+---
+
+## v0.70.0​
+
+- fix(compaction): move decision logic to orchestrator for better separation of concerns @tusharmath (#679)
+
+---
+
+## v0.69.0​
+
+- fix(compaction): improve context summarization with authoritative framing @tusharmath (#678)
+
+---
+
+## v0.68.0​
+
+- feat(compact): add /compact command to reduce context size @tusharmath (#674)
+
+---
+
+## v0.67.0​
+
+- feat(shell): use ! to run arbitary shell commands without exiting. @tusharmath (#672)
+- perf(models): implement model caching to improve selection performance @tusharmath (#675)
+
+### 📝 Documentation​
+
+- docs: update README for improved getting started instructions and provider configuration @tusharmath (#676)
+
+- feat(shell): use ! to run arbitary shell commands without exiting. @tusharmath (#672)
+
+---
+
+## v0.66.2​
+
+- fix: remove redundant title agent functionality and related code @tusharmath (#673)
+
+- fix: remove redundant title agent functionality and related code @tusharmath (#673)
+
+---
+
+## v0.66.1​
+
+- fix(ui): handle errors in model selection prompt @tusharmath (#671)
+
+---
+
+## v0.66.0​
+
+- feat(cli): add /model command for interactive model selection @tusharmath (#667)
+
+---
+
+## v0.65.0​
+
+- feat: shell style prompt improvements @tusharmath (#670)
+
+---
+
+## v0.64.3​
+
+- fix: add default value for agents in Workflow struct @tusharmath (#668)
+
+---
+
+## v0.64.2​
+
+- fix: broken CLI formatting @tusharmath (#662)
+
+- fix: broken CLI formatting @tusharmath (#662)
+
+---
+
+## v0.64.1​
+
+- fix: broken STDIO @tusharmath (#661)
+
+---
+
+## v0.64.0​
+
+- feat: ability to customize default agent @tusharmath (#657)
+
+- feat: ability to customize default agent @tusharmath (#657)
+- chore(deps): bump tokio from 1.43.0 to 1.44.2 @dependabot[bot] (#636)
+- chore(deps): bump crossbeam-channel from 0.5.14 to 0.5.15 @dependabot[bot] (#658)
+
+---
+
+## v0.63.0​
+
+- refactor: clean up auto-update @tusharmath (#652)
+
+- feat: setting up default models @tusharmath (#655)
+
+---
+
+## v0.62.0​
+
+- feat: implement auto update functionality @tusharmath (#651)
+
+---
+
+## v0.61.1​
+
+- fix: improve auto-compaction logic @tusharmath (#640)
+
+---
+
+## v0.61.0​
+
+- feat: initialize a conversation from a dump file @tusharmath (#638)
+
+---
+
+## v0.60.3​
+
+- fix: attachment parsing @tusharmath (#635)
+
+---
+
+## v0.60.2​
+
+- fix: retry on upstream errors @amitksingh1490 (#620)
+
+---
+
+## v0.60.1​
+
+- fix: remove timeout @amitksingh1490 (#631)
+
+---
+
+## v0.60.0​
+
+- feat: log request url with errors for more clearity @laststylebender14 (#608)
+
+- fix: file-search tool should be used to search for files @tusharmath (#627)
+
+---
+
+## v0.59.2​
+
+- refactor: simplify command output formatting in shell execution @tusharmath (#626)
+
+- fix: client connection settings @amitksingh1490 (#625)
+
+---
+
+## v0.59.1​
+
+- fix: update system prompt to conditionally display custom rules section @tusharmath (#623)
+
+---
+
+## v0.59.0​
+
+- feat: add comprehensive documentation for new features including coding agent, built-in commands, security, image upload, autocomplete, multi-agent architecture, WYSIWYG shell experience, and command interruption @tusharmath (#622)
+
+- feat: add comprehensive documentation for new features including coding agent, built-in commands, security, image upload, autocomplete, multi-agent architecture, WYSIWYG shell experience, and command interruption @tusharmath (#622)
+
+---
+
+## v0.58.1​
+
+- fix: implement System Prompts for plan mode @tusharmath (#617)
+
+---
+
+## v0.58.0​
+
+- feat: use request token usage for compaction @laststylebender14 (#600)
+
+---
+
+## v0.57.0​
+
+- feat: Enhance System Context with Dynamic Variables and Re-rendering @tusharmath (#614)
+
+---
+
+## v0.56.0​
+
+- feat: make forge LMStudio compatible @laststylebender14 (#613)
+
+---
+
+## v0.55.1​
+
+- fix: update naming convention for plan Markdown files @tusharmath (#610)
+
+- refactor: remove Qdrant and OpenAI embedding service references from the codebase @tusharmath (#609)
+
+---
+
+## v0.55.0​
+
+- feat: implement undo tool @laststylebender14 (#596)
+
+---
+
+## v0.54.0​
+
+- fix: improve write message for fs_write tool @tusharmath (#607)
+
+---
+
+## v0.53.6​
+
+- fix: preserve coloured output for sbt tests @laststylebender14 (#604)
+
+---
+
+## v0.53.5​
+
+- feat: add current time with user prompts @tusharmath (#606)
+
+---
+
+## v0.53.4​
+
+- feat: enhance context summarization with standardized templates and configuration @tusharmath (#605)

homelab/raw/articles/forge/reference/releases-2025-August.md

@@ -0,0 +1,197 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/releases/2025/August/
+scraped: 2026-04-28T21:02:29.273189+00:00
+content_hash: 091c9eb9
+---
+# August
+
+Update to latest version !!
+Get the instructions from the docs
+[Get Started](https://forgecode.dev/docs/)
+## v0.112.0​
+
+### 🚀 Features​
+
+- feat: show usage on completion @manthanabc (#1448)
+
+### 🐛 Bug Fixes​
+
+- fix: sync conversation before completion @manthanabc (#1465)
+- chore(deps): bump the patch group with 12 updates @dependabot[bot] (#1458)
+- fix: agent response format @tusharmath (#1457)
+- fix: fixed metrics usages in orch.rs @manthanabc (#1449)
+
+### 🧰 Maintenance​
+
+- chore(deps): bump the patch group with 12 updates @dependabot[bot] (#1458)
+- chore(deps): bump the minor group with 2 updates @dependabot[bot] (#1459)
+- refactor: rename tools for consistency and clarity @tusharmath (#1453)
+
+---
+
+## v0.111.0​
+
+- feat: add Cerebras provider support @amitksingh1490 (#1446)
+- feat: add support for z.ai provider @amitksingh1490 (#1443)
+- feat: AGENTS.md support @jayantpranjal0 (#1395)
+
+- fix: improve sub-agent traces @tusharmath (#1444)
+- fix: implement set-cache transformer and usage for Anthropic @amitksingh1490 (#1439)
+- fix: improve system prompt caching @laststylebender14 (#1441)
+
+- fix: improve sub-agent traces @tusharmath (#1444)
+- chore: clean up posthog implementation @laststylebender14 (#1415)
+
+---
+
+## v0.110.1​
+
+- fix: agent level custom rules not getting attached when default custom rules are defined @jayantpranjal0 (#1422)
+- fix: prevent tool call notifications for agent tools @tusharmath (#1436)
+- fix: improve format for reasoning messages @tusharmath (#1432)
+
+---
+
+## v0.110.0​
+
+- feat: use agent to agent communication in forge @tusharmath (#1430)
+- feat: add researcher - SAGE @tusharmath (#1426)
+- feat: Open new chat on completion @manthanabc (#1301)
+
+- fix: drop forced login for users @tusharmath (#1431)
+- fix: improve agent-2-agent communication via tool call @tusharmath (#1428)
+- fix: improve cache breakpoints @amitksingh1490 (#1424)
+- fix: send tool call errors as feedback @tusharmath (#1411)
+- fix: update summarization prompt for plan files @tusharmath (#1419)
+
+- fix: improve agent-2-agent communication via tool call @tusharmath (#1428)
+- chore: drop task management tools @tusharmath (#1429)
+- feat: Open new chat on completion @manthanabc (#1301)
+
+---
+
+## v0.109.2​
+
+- fix: update README for clarity and organization of setup instructions @amitksingh1490 (#1418)
+- fix: prevent overflow in eviction logic for empty or single message context @amitksingh1490 (#1412)
+- fix: ensure tool_choice is set only when tools are defined in the req @amitksingh1490 (#1414)
+- fix: disable login call on start and update provider error message. @amitksingh1490 (#1417)
+- Revert "fix: ensure tool_choice is set only when tools are defined in… @amitksingh1490 (#1413)
+
+---
+
+## v0.109.1​
+
+- fix: optimize user input handling in Console by removing block_in_place @tusharmath (#1408)
+- fix: revert permissions check @tusharmath (#1407)
+- fix: handle numeric pricing in OpenAI-compatible APIs @tusharmath (#1403)
+
+---
+
+## v0.109.0​
+
+- feat: add new agents for documentation review and technical writing @amitksingh1490 (#1397)
+
+- fix: update formatting for sections in prompt template @tusharmath (#1400)
+- fix: update permissions to allow all read, write, command, and url access @tusharmath (#1401)
+
+---
+
+## v0.108.0​
+
+- feat: Added configurable timeout for tools (#1249) @manthanabc (#1293)
+- chore: CLI capabilities for system permissions @ssddOnTop (#1334)
+- feat: add /usage command @laststylebender14 (#1365)
+
+- fix: windows file attachments @jayantpranjal0 (#1394)
+- fix: use cwd to identify plan dir @tusharmath (#1391)
+- fix: split compaction handling into system and user message @laststylebender14 (#1390)
+- fix: show only date in user prompt @laststylebender14 (#1389)
+- fix: removed dead code @manthanabc (#1384)
+- fix: summarization prompt improvements @tusharmath (#1382)
+
+- chore: treat policy denial as success response @ssddOnTop (#1385)
+- chore: consolidate tool usage instructions into main template and remove partial @tusharmath (#1392)
+- refactor: replace tokio::sync::Mutex with std::sync::Mutex in input.rs @tusharmath (#1393)
+- fix: use cwd to identify plan dir @tusharmath (#1391)
+- chore: update checkout action @manthanabc (#1388)
+- chore(deps): bump slab from 0.4.10 to 0.4.11 @dependabot[bot] (#1375)
+- chore: CLI capabilities for system permissions @ssddOnTop (#1334)
+
+---
+
+## v0.107.0​
+
+- feat: forge sandbox @tusharmath (#1371)
+
+- fix: compaction token_count logic @jayantpranjal0 (#1343)
+- fix: system lag on exit @laststylebender14 (#1377)
+- fix: context limit being exceeded with image URLs @tusharmath (#1372)
+
+- chore(deps): bump uuid from 1.17.0 to 1.18.0 in the minor group @dependabot[bot] (#1369)
+
+---
+
+## v0.106.0​
+
+- feat: implement special plan creation tool @tusharmath (#1366)
+
+- fix: tweaks to handle plans better @tusharmath (#1364)
+- fix: add schemars dependency and ensure OpenAI compatibility @amitksingh1490 (#1361)
+- fix: enhance error handling in ChatCompletionMessage @tusharmath (#1360)
+- fix: add cache hydration in new conversation handling @tusharmath (#1358)
+- fix: attempt retry on empty responses @tusharmath (#1356)
+- fix: update error handling in agent loading and improve YAML schema reference @tusharmath (#1353)
+- chore: update rust-toolchain @jayantpranjal0 (#1352)
+
+- refactor: move provider dtos into forge_app/dto @tusharmath (#1362)
+
+---
+
+## v0.105.0​
+
+- feat: parse line start end symbol in attachment @laststylebender14 (#1345)
+- feat: using frontmatter to define agents @ssddOnTop (#1152)
+
+- fix: improve attempt completion requirements @tusharmath (#1346)
+- fix: improve response performance @tusharmath (#1342)
+- fix: update workflow configuration and enhance template guidelines @tusharmath (#1341)
+- fix: improve system prompt structure @tusharmath (#1339)
+- fix: update line truncation to handle character count and add unicode tests @tusharmath (#1340)
+
+### 🚀 Performance​
+
+- fix: improve response performance @tusharmath (#1342)
+
+- refactor: move forge_provider into forge_services/provider @jayantpranjal0 (#1333)
+
+---
+
+## v0.104.4​
+
+- fix: improve tool truncation performance @laststylebender14 (#1203)
+- fix: add system time in user prompt @laststylebender14 (#1331)
+- fix: remove instructions that were not helping @tusharmath (#1329)
+- fix: show time in d h m s format @laststylebender14 (#1327)
+- chore(deps): bump the patch group with 5 updates @dependabot[bot] (#1320)
+- fix: add label for switching model in banner display @amitksingh1490 (#1323)
+- fix: handle file names with special chars in fuzzy matcher @jayantpranjal0 (#1310)
+- fix: new command should reset the conversation @PoulavBhowmick03 (#1220)
+- fix: add HTTP/2 support and improve error handling in ForgeHttpInfra @amitksingh1490 (#1315)
+
+- chore: add tests for orchestrator @tusharmath (#1325)
+- chore(deps): bump the patch group with 5 updates @dependabot[bot] (#1320)
+- chore: add labels ci: build all targets @tusharmath (#1324)
+- chore: update dependencies @reneleonhardt (#1256)
+- fix: handle file names with special chars in fuzzy matcher @jayantpranjal0 (#1310)
+
+---
+
+## v0.104.3​
+
+- fix: compact settings in forge.yaml @jayantpranjal0 (#1268)
+- fix: remove unused system time variable from template @tusharmath (#1307)
+- fix: use relative path for autocomplete fuzzy match @jayantpranjal0 (#1297)
+- fix: parsing empty MCP configuration @Achyutha (#1304)

homelab/raw/articles/forge/reference/releases-2025-January.md

@@ -0,0 +1,211 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/releases/2025/January/
+scraped: 2026-04-28T21:02:42.903687+00:00
+content_hash: 126ffe77
+---
+# January
+
+Update to latest version !!
+Get the instructions from the docs
+[Get Started](https://forgecode.dev/docs/)
+## v0.1.2​
+
+- ci: update release drafter configuration for pull request_target @amitksingh1490 (#261)
+
+### 🚀 Features​
+
+- feat: enhance CI workflow with draft release and versioning support @amitksingh1490 (#266)
+- feat: drop support for file parsing in user prompt @laststylebender14 (#262)
+
+### 🐛 Bug Fixes​
+
+- fix(deps): update rust crate diesel to v2.2.7 @renovate[bot] (#264)
+- fix: drop the task in chat.rs as soon as base stream is dropped @laststylebender14 (#259)
+
+---
+
+## v0.1.1​
+
+### What's Changed​
+
+- feat: pass on transformations for open router requests @laststylebender14 (#260)
+
+### 👥 Contributors​
+
+@amitksingh1490 and @laststylebender14
+
+---
+
+## v0.1.0​
+
+- feat: migrate release drafter workflow to root directory and update t… @amitksingh1490 (#257)
+- chore(deps): update release-drafter/release-drafter action to v6 @renovate[bot] (#254)
+- feat: add release drafter workflow for automated release updates @amitksingh1490 (#256)
+- feat: add CI workflow for multi-platform release builds and update de… @amitksingh1490 (#253)
+- feat: add CI workflow for multi-platform release @amitksingh1490 (#250)
+- feat(patch): introduce ApplyPatchV2 with enhanced fuzzy matching @tusharmath (#242)
+- feat: add CI workflow for release @amitksingh1490 (#247)
+- chore(deps): update rust crate gh-workflow-tailcall to v0.5.1 @renovate[bot] (#248)
+- feat: create a single global database @ssddOnTop (#246)
+- fix(deps): update rust crate serde_json to v1.0.138 @renovate[bot] (#244)
+- fix(deps): update rust crate tempfile to v3.16.0 @renovate[bot] (#245)
+- fix: update Walker initialization to use min and max methods @tusharmath (#241)
+- fix: disable overwrite feature on fs_write. @tusharmath (#240)
+- refactor: reorganize conversation history handling and improve structure @tusharmath (#239)
+- fix: walker settings for fs-find @tusharmath (#236)
+- feat: add new forge_inte crate @tusharmath (#227)
+- fix(deps): update nom usage @tusharmath (#234)
+- fix(deps): update rust crate nom to v8 @renovate[bot] (#233)
+- refactor: increase tool call timeout duration in service and tests @amitksingh1490 (#231)
+- outline tests @tusharmath (#228)
+- refactor: convert status labels to lowercase @tusharmath (#229)
+- refactor: remove think tool debug messages @tusharmath (#224)
+- tests: add test for multiple tool calls @laststylebender14 (#220)
+- chore(deps): update rust crate insta to v1.42.1 @renovate[bot] (#225)
+- feat: make all tools require absolute path @tusharmath (#222)
+- refactor: add SuggestionService @tusharmath (#219)
+- refactor: implement FileReadService for file reading operations @tusharmath (#218)
+- fix(deps): update rust crate derive_builder to 0.20.0 @renovate[bot] (#217)
+- context overload error @tusharmath (#216)
+- feat: add support for multiple tool calls @laststylebender14 (#213)
+- refactor: streamline database connection handling across repositories @tusharmath (#211)
+- refactor: add better context to errors @tusharmath (#210)
+- fix: unwrap results of async send calls for better error handling @tusharmath (#208)
+- merge conversation repo @tusharmath (#207)
+- refactor: improve error handling by mapping errors to specific contexts and updating error messages @tusharmath (#206)
+- fix: drop stream if recv is closed @laststylebender14 (#203)
+- feat: allow control + c to stop the conversation @laststylebender14 (#204)
+- fix: improve SQLite connection handling @tusharmath (#205)
+- fix(deps): update rust crate crossterm to 0.28 @renovate[bot] (#201)
+- feat: stop stream exec when esc is pressed @laststylebender14 (#199)
+- refactor: clean up tests @tusharmath (#198)
+- refactor: drop routes use API directly @tusharmath (#197)
+- test: add snapshot tests for patch apply functionality @tusharmath (#195)
+- fix(deps): update rust crate axum to v0.8.2 @renovate[bot] (#193)
+- tests: add supported models in e2e @laststylebender14 (#185)
+- feat: add support for custom instructions in chat requests and UI initialization @tusharmath (#191)
+- fix(deps): update rust crate uuid to v1.12.1 @renovate[bot] (#190)
+- fix(deps): update rust crate clap to v4.5.27 @renovate[bot] (#187)
+- feat: make gemini flash work @laststylebender14 (#184)
+- feat: make models work with tools @laststylebender14 (#183)
+- refactor: optimize patch @tusharmath (#180)
+- fix(deps): update rust crate serde_json to v1.0.137 @renovate[bot] (#181)
+- feat: fs write overwrite @tusharmath (#179)
+- chore(deps): update rust crate gh-workflow-tailcall to 0.5.0 @renovate[bot] (#178)
+- refactor: improve tool descriptions for clarity and conciseness @tusharmath (#176)
+- fix: replace errors now contain index of the error @tusharmath (#171)
+- feat: improve caching mechanism for system/user messages and add unit tests @tusharmath (#175)
+- fix(deps): update rust crate serde_json to v1.0.136 @renovate[bot] (#173)
+- feat: enhance banner with AI capabilities and update help text format @tusharmath (#172)
+- docs: update documentation to support multiple SEARCH/REPLACE blocks @tusharmath (#169)
+- fix: implement directory creation for file writes and add related tests @tusharmath (#168)
+- feat: add token usage in CLI @tusharmath (#167)
+- test: add integration tests for LLMs @tusharmath (#161)
+- fix: improve syntax validation error handling and messages @tusharmath (#165)
+- fix: improve syntax validation error handling and messages @tusharmath (#160)
+- fix: remove timeout enforcement from shell command execution and related tests @tusharmath (#158)
+- fix: refactor ToolResult handling to use success and failure methods for better clarity @tusharmath (#159)
+- fix: implement display upstream error @laststylebender14 (#132)
+- refactor: drop model from context @tusharmath (#151)
+- refactor: env root api refac @tusharmath (#156)
+- fix: always display tool call results on error or in verbose mode @tusharmath (#157)
+- tool name convention @tusharmath (#155)
+- info command @tusharmath (#152)
+- tool timeout @tusharmath (#153)
+- refactor: remove implementation of model @tusharmath (#150)
+- feat: impl fetch tool @laststylebender14 (#147)
+- fix(deps): update rust crate handlebars to v6 @renovate[bot] (#149)
+- feat: initial work for custom agents @tusharmath (#148)
+- fix(deps): update rust crate moka2 to 0.13 @renovate[bot] (#144)
+- feat: add user input handling with command parsing and validation @tusharmath (#143)
+- feat: integrate anyhow for error handling across services @tusharmath (#142)
+- fix: tool_choice encoding/decoding error @tusharmath (#141)
+- fix(deps): update rust crate thiserror to v2 @renovate[bot] (#140)
+- chore: avoid Crash on invalid command @ssddOnTop (#139)
+- fix(deps): update rust crate uuid to v1.12.0 @renovate[bot] (#135)
+- fix: when search block is empty, add the replace box text to the end of the file. @laststylebender14 (#126)
+- feat: raise upstream errors @laststylebender14 (#124)
+- feat: add timeout functionality to shell tool @laststylebender14 (#125)
+- infrastructure migration @tusharmath (#130)
+- feat: enhance user input handling with reload command @tusharmath (#129)
+- feat: display errors on cli @laststylebender14 (#123)
+- chore(deps): update autofix-ci/action digest to 551dded @renovate[bot] (#121)
+- fix(deps): update rust crate dirs to v6 @renovate[bot] (#120)
+- fix(deps): update rust crate tree-sitter to v0.24.7 @renovate[bot] (#119)
+- fix(deps): update rust crate tree-sitter-css to v0.23.2 @renovate[bot] (#117)
+- fix(deps): update rust crate inquire to 0.7.0 @renovate[bot] (#115)
+- fix(deps): update rust crate proc-macro2 to v1.0.93 @renovate[bot] (#114)
+- Add-support-for-popular-languages @amitksingh1490 (#112)
+- fix(deps): update rust crate unicode-width to 0.2.0 @renovate[bot] (#111)
+- fix(deps): update rust crate thiserror to v2.0.11 @renovate[bot] (#100)
+- fix(deps): update rust crate uuid to v1.11.1 @renovate[bot] (#105)
+- fix(deps): update rust crate clap to v4.5.26 @renovate[bot] (#103)
+- fix(deps): update rust crate clap to v4.5.25 @renovate[bot] (#102)
+- feat: generate title for conversation @laststylebender14 (#87)
+- feat: store settings in db @laststylebender14 (#88)
+- fix: search the text recursively in the folder. @laststylebender14 (#94)
+- feat: syntax validator @tusharmath (#98)
+- fix(deps): update rust crate thiserror to v2.0.10 @renovate[bot] (#97)
+- fix(deps): update rust crate tokio to v1.43.0 @renovate[bot] (#96)
+- feat: add support of cwd to shell command @laststylebender14 (#93)
+- fix(deps): update rust crate clap to v4.5.24 @renovate[bot] (#92)
+- fix(deps): update rust crate colored to v3 @renovate[bot] (#91)
+- fix(deps): update rust crate async-trait to v0.1.85 @renovate[bot] (#89)
+- refactor: Move storage out of chat-service @amitksingh1490 (#86)
+- fix(deps): update rust crate handlebars to v6.3.0 @renovate[bot] (#85)
+- chore(deps): update rust crate insta to v1.42.0 @renovate[bot] (#84)
+- Handle new chat @amitksingh1490 (#83)
+- Storage-service @amitksingh1490 (#79)
+- fix(deps): update rust crate tree-sitter-rust to 0.23.0 @renovate[bot] (#15)
+- fix(deps): update rust crate tree-sitter-javascript to 0.23.0 @renovate[bot] (#13)
+- fix(deps): update rust crate tree-sitter-python to 0.23.0 @renovate[bot] (#14)
+- fix(deps): update rust crate tree-sitter to 0.24.0 @renovate[bot] (#12)
+- fix(deps): update rust crate pulldown-cmark to 0.12.0 @renovate[bot] (#57)
+- feat: improve user prompt @tusharmath (#77)
+- fix(deps): update rust crate async-trait to v0.1.84 @renovate[bot] (#76)
+- fix(deps): update rust crate tempfile to v3.15.0 @renovate[bot] (#74)
+- tests: tests for neo chat svc @laststylebender14 (#73)
+- fix(deps): update rust crate axum to v0.8.1 @renovate[bot] (#71)
+- fix(deps): update rust crate axum to ^0.8.0 @renovate[bot] (#70)
+- fix(deps): update rust crate reqwest to v0.12.12 @renovate[bot] (#69)
+- Sequential Thinking @amitksingh1490 (#60)
+- chore(deps): update rust crate gh-workflow-tailcall to v0.2.1 @renovate[bot] (#64)
+- refactor: remove redundant tool response tests for improved clarity @tusharmath (#63)
+- fix(deps): update rust crate glob to v0.3.2 @renovate[bot] (#62)
+- feat: add dissimilar crate for fuzzy string matching in fs_replace @amitksingh1490 (#53)
+- chore: add some tests @ssddOnTop (#56)
+- fix(deps): update rust crate serde to v1.0.217 @renovate[bot] (#55)
+- refactor: update FSWrite to return structured output and enhance output schema @amitksingh1490 (#54)
+- fix(deps): update rust crate reqwest to v0.12.11 @renovate[bot] (#52)
+- refactor: introduce ToolUsePart @tusharmath (#50)
+- refactor: fix fs_replace @amitksingh1490 (#48)
+- fix(deps): update rust crate reqwest to v0.12.10 @renovate[bot] (#46)
+- fix: match tool prompts and add concrete unit tests. @laststylebender14 (#43)
+- fix tests @ssddOnTop (#47)
+- feat: add more env variables @laststylebender14 (#44)
+- feat: render templates in sysprompt. @laststylebender14 (#42)
+- fix: use forge walker in fs_list @laststylebender14 (#41)
+- fix(deps): update rust crate quote to v1.0.38 @renovate[bot] (#37)
+- fix: send tool response to llm @laststylebender14 (#40)
+- chore: comment unnecessary tools @laststylebender14 (#39)
+- fix: make tools work @laststylebender14 (#38)
+- chore: add tests for app @ssddOnTop (#36)
+- add app_runtime.rs @ssddOnTop (#35)
+- fix(deps): update rust crate derive_more to v1 @renovate[bot] (#31)
+- chore: stream chat instead of making it sequential @ssddOnTop (#29)
+- chore: drop prompt @ssddOnTop (#27)
+- fix(deps): update rust crate tower-http to 0.6 @renovate[bot] (#25)
+- fix: tests @ssddOnTop (#26)
+- add new provider models @tusharmath (#21)
+- feat: suggest file names when user types @ and some file name @laststylebender14 (#19)
+- feat: add sys prompt @laststylebender14 (#18)
+- feat: impl tool for fs @laststylebender14 (#17)
+- feat: add mcp server client and file-system server @laststylebender14 (#16)
+- fix: add forge-outline crate @amitksingh1490 (#11)
+- chore: Configure Renovate @renovate[bot] (#1)
+- Fix failing tests in src/error.rs @tusharmath (#3)
+- feat: add basic LLM capabilities @tusharmath (#2)
+
+@amitksingh1490, @autofix-ci[bot], @laststylebender14, @renovate[bot], @ssddOnTop, @tusharmath, AI Assistant and renovate[bot]

homelab/raw/articles/forge/reference/releases-2025-July.md

@@ -0,0 +1,280 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/releases/2025/July/
+scraped: 2026-04-28T21:02:28.372280+00:00
+content_hash: 9adc370f
+---
+# July
+
+Update to latest version !!
+Get the instructions from the docs
+[Get Started](https://forgecode.dev/docs/)
+## v0.104.2​
+
+### 🐛 Bug Fixes​
+
+- fix: improve error message handling @tusharmath (#1302)
+- fix: use antinomy domain @tusharmath (#1300)
+
+### 🧰 Maintenance​
+
+- refactor: move common event parsing logic outside @tusharmath (#1303)
+
+---
+
+## v0.104.1​
+
+- fix: support TLS version configuration via env variables @tusharmath (#1299)
+
+---
+
+## v0.104.0​
+
+### 🚀 Features​
+
+- fix: integrate JSON repair @ssddOnTop (#1292)
+- feat: added info command (#1273) @manthanabc (#1275)
+
+### 📝 Documentation​
+
+- fix: update tool use formatting rules to clarify JSON structure @amitksingh1490 (#1291)
+
+- fix: sort the models based on the names @Achyutha (#1284)
+- fix: integrate JSON repair @ssddOnTop (#1292)
+
+- fix: consolidate HTTP client implementations and use TLS configurators @tusharmath (#1288)
+
+---
+
+## v0.103.0​
+
+- feat: Support for /retry @jayantpranjal0 (#1262)
+
+- fix: mcp ToolName sanitization @tusharmath (#1274)
+- fix: add Cross.toml for build environment configuration @ssddOnTop (#1272)
+
+- refactor: simplify tracking logic @tusharmath (#1276)
+
+---
+
+## v0.102.2​
+
+- fix: update error element to tool_call_error in templates @tusharmath (#1254)
+- Revert "fix: drop reasoning normalizer" @laststylebender14 (#1245)
+- fix: show usage information @ssddOnTop (#1250)
+
+---
+
+## v0.102.1​
+
+- fix: update provider state after successful login @ssddOnTop (#1234)
+- fix: enhance path formatting for display @ssddOnTop (#1233)
+
+- chore: add cached_tokens usage to tracing @jayantpranjal0 (#1200)
+- chore: add FORGE_SUPPRESS_RETRY_ERRORS env variable to hide retry error @ssddOnTop (#1231)
+
+---
+
+## v0.102.0​
+
+- feat: use fuzzy find in autocomplete @ssddOnTop (#1214)
+
+- fix: use custom binary file detector @laststylebender14 (#1225)
+- fix: drop reasoning normalizer @laststylebender14 (#1216)
+- fix: use cross for musl build @ssddOnTop (#1210)
+
+- chore: rename provider to openai @tusharmath (#1199)
+
+---
+
+## v0.101.1​
+
+- fix: ensure reasoning config is dropped @tusharmath (#1198)
+
+---
+
+## v0.101.0​
+
+- fix: remove reasoning tokens after compaction @tusharmath (#1196)
+- feat: support for current working directory @tusharmath (#1174)
+
+- feat: support for current working directory @tusharmath (#1174)
+
+---
+
+## v0.100.8​
+
+- fix: use actual usage data for compaction @tusharmath (#1176)
+- fix: update binary extensions @tusharmath (#1193)
+- fix: always skip searching through binary files in fs_search @laststylebender14 (#1187)
+- fix: add support for viewing MCP responses @tusharmath (#1175)
+- fix: update token reporting logic in ForgePrompt @tusharmath (#1179)
+- fix: drop hickory dns resolver @laststylebender14 (#1190)
+- fix: change default option to continue in confirmation prompt @laststylebender14 (#1186)
+
+- chore: add label for OnlyDust Wave Hackathon @amitksingh1490 (#1191)
+
+---
+
+## v0.100.7​
+
+- doc: update the setting name (max_tool_failure_per_turn) @laststylebender14 (#1154)
+
+- fix: use ranges in file attachments @tusharmath (#1162)
+- fix: use hickory-dns resolver instead of Gai @laststylebender14 (#1130)
+- fix: signature is not required for summarization @laststylebender14 (#1158)
+- fix: skip binary files while searching @laststylebender14 (#1157)
+
+- chore(deps): update strum monorepo to v0.27.2 @renovate[bot] (#1145)
+
+---
+
+## v0.100.6​
+
+- fix: kimi2 tool call errors @ssddOnTop (#1144)
+- fix: use search directory for relative paths in search results instead of CWD @tusharmath (#1139)
+
+- chore: add forge_main_neo @tusharmath (#998)
+
+---
+
+## v0.100.5​
+
+- fix: file search invalid utf8 issue @ssddOnTop (#1132)
+
+- refactor: consolidate inquire select functionality into select module @echozyr2001 (#1128)
+- chore: log file update stats @laststylebender14 (#1118)
+
+---
+
+## v0.100.4​
+
+- fix: handle tool calls from Kimi2 @tusharmath (#1121)
+
+- chore: update edition to 2024 @tusharmath (#1125)
+
+---
+
+## v0.100.3​
+
+- fix: replace tracker error logging with tracing @tusharmath (#1117)
+
+---
+
+## v0.100.2​
+
+- fix: scripts for npx for Windows
+
+---
+
+## v0.100.1​
+
+### 🛠️ Refactors​
+
+- refactor: consolidate forge_api_url usage @tusharmath, @autofix-ci[bot] (#1104)
+
+- fix: output reasoning tokens only if supported by model @laststylebender14 (#1105)
+- fix: update HTTP-Referer header to point to the new forgecode.dev URL @amitksingh1490 (#1080)
+- fix: improve LLM caching @tusharmath (#1088)
+- fix: use max_completion_tokens instead of max_tokens for open-ai compatible providers @laststylebender14 (#1086)
+- fix: use blocking thread to readline @tusharmath (#1085)
+
+- fix: share release builds between channels @tusharmath (#1114)
+- fix: regenerate binaries on publish @laststylebender14 (#1113)
+- chore: remove forge_domain direct dependency on crates @tusharmath (#1084)
+- chore: update labels.yml @ssddOnTop (#1082)
+- chore: add permissions to GitHub Label Sync workflow @ssddOnTop (#1078)
+- chore: add GitHub Label Sync workflow and related tests @ssddOnTop (#1077)
+
+- docs: update readme for max_requests_per_turn and tool_max_failure_limit @laststylebender14 (#1027)
+
+---
+
+## v0.100.0​
+
+- docs: update readme for max_requests_per_turn and tool_max_failure_limit @laststylebender14 (#1027)
+
+- fix: update HTTP-Referer header to point to the new forgecode.dev URL @amitksingh1490 (#1080)
+- fix: improve LLM caching @tusharmath (#1088)
+- fix: use max_completion_tokens instead of max_tokens for open-ai compatible providers @laststylebender14 (#1086)
+- fix: use blocking thread to readline @tusharmath (#1085)
+
+- chore: remove forge_domain direct dependency on crates @tusharmath (#1084)
+- chore: update labels.yml @ssddOnTop (#1082)
+- chore: add permissions to GitHub Label Sync workflow @ssddOnTop (#1078)
+- chore: add GitHub label sync workflow and related tests @ssddOnTop (#1077)
+
+---
+
+## v0.99.0​
+
+- chore: integrate provider_auth_id @ssddOnTop (#1072)
+- feat(provider): implement model caching with cache-first pattern @tusharmath (#1071)
+- feat: enhance conversation compaction with per-trigger thresholds and turn-end support @tusharmath (#1068)
+- feat: add x.ai provider support with API integration @amitksingh1490 (#1066)
+
+- fix: reasoning with compaction @laststylebender14 (#1059)
+- fix: /dump Errors when there's no ConversationId @Achyutha (#1065)
+- fix: increase default connect timeout @ssddOnTop (#1070)
+- fix: run chat request and compaction in parallel @ssddOnTop (#1067)
+
+- chore: integrate provider_auth_id @ssddOnTop (#1072)
+
+---
+
+## v0.98.3​
+
+- fix: update default read_timeout to 5 minutes @tusharmath (#1064)
+- fix: cache posthog client @tusharmath (#1063)
+- fix: remove auto compaction after each turn @tusharmath (#1062)
+
+---
+
+## v0.98.2​
+
+- fix: error tracing before exiting @amitksingh1490 (#1058)
+- fix: add JSON parse error handling to retry logic @ssddOnTop (#1056)
+- fix: use auth_provider_id instead of email @ssddOnTop (#1054)
+- fix: panic while writing app config without parent dirs @ssddOnTop (#1057)
+- fix: add new line when appending @laststylebender14 (#1052)
+- fix(deps): update rust crate thiserror to v2 @renovate[bot] (#1043)
+
+- chore: add login event @ssddOnTop (#1035)
+
+---
+
+## v0.98.1​
+
+- Update README.md @amitksingh1490 (#1036)
+
+- fix: resolve login error by ensuring provider initialization in UI state @ssddOnTop (#1049)
+- fix: add environment variable support for HTTP connect timeouts @tusharmath (#1046)
+- fix: update login terminology for consistency in commands and UI messages @tusharmath (#1034)
+
+- chore(deps): update rust crate syn to v2.0.104 @renovate[bot] (#1042)
+- chore(deps): update rust crate anyhow to v1.0.98 @renovate[bot] (#1041)
+
+---
+
+## v0.98.0​
+
+- feat: display reasoning tokens @laststylebender14 (#1025)
+- feat: implement tool failure limit in orchestrator @laststylebender14 (#1024)
+- feat: ask if user wish to continue or not on max_request_per_turn @laststylebender14 (#1014)
+- feat: implement login and logout functionality @ssddOnTop (#838)
+- feat: add replace-all variant to patch tool @laststylebender14 (#1011)
+
+- fix: remove Rust toolchain update step from CI jobs and add rust-toolchain @amitksingh1490 (#1032)
+- refactor: correct limit @tusharmath (#1030)
+- fix: stop spinner after login completion @ssddOnTop (#1029)
+- fix: ask agent to self reflect on errors @laststylebender14 (#1023)
+- fix: add citation rule for code references in prompts @laststylebender14 (#1017)
+- fix: read larger chunks whenever possible @laststylebender14 (#1009)
+- fix: report more readable errors back to LLM @laststylebender14 (#1016)
+- chore: add tracker for panic hook @tusharmath (#1022)
+- fix: display retry events on cli @laststylebender14 (#1010)
+- fix: replace panic with proper error handling in API key resolution @echozyr2001 (#1013)
+
+- chore: use standard ignore filters in walker @laststylebender14 (#1015)
+- chore: add Requesty as a Provider @Thibault00 (#1018)

homelab/raw/articles/forge/reference/releases-2025-June.md

@@ -0,0 +1,164 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/releases/2025/June/
+scraped: 2026-04-28T21:02:40.171147+00:00
+content_hash: cde04483
+---
+# June
+
+Update to latest version !!
+Get the instructions from the docs
+[Get Started](https://forgecode.dev/docs/)
+## v0.97.1​
+
+- Update README.md @amitksingh1490 (#1002)
+
+### 🐛 Bug Fixes​
+
+- fix: update README to correct JSON key for MCP servers @ssddOnTop (#1007)
+- fix: utilise the total_tokens in compaction @laststylebender14 (#1005)
+- fix: sanitize headers before logging @laststylebender14 (#1006)
+- fix: show upstream error message on ui @laststylebender14 (#1000)
+- fix(ui): update init_state to handle API recreation flag @ssddOnTop (#1003)
+- fix: update the npm update command @laststylebender14 (#1001)
+
+---
+
+## v0.97.0​
+
+### 🚀 Features​
+
+- feat: implement task list management tool with CRUD operations @ssddOnTop (#991)
+
+- fix(walker): handle large directories @tusharmath (#995)
+
+### 🧰 Maintenance​
+
+- refactor: migrate walker functionality to forge_infra with new abstractions @tusharmath (#994)
+
+---
+
+## v0.96.2​
+
+- test: add unit test for call ID extraction from XML @tusharmath (#989)
+
+- fix: improve function call schema to work with open-ai @laststylebender14 (#972)
+- fix: generate unique call ID for tool calls when parsing from XML @tusharmath (#988)
+
+- chore: add more tests for can_track @tusharmath (#992)
+
+---
+
+## v0.96.1​
+
+- ci: implement matrix strategy for multiple NPM repositories @amitksingh1490 (#983)
+
+- fix(ui): improve model list display with context length and tool support @tusharmath (#986)
+- fix(compaction): handle parallel tool calls in context compaction @laststylebender14 (#984)
+- fix: ask for update only on 1st init @laststylebender14 (#985)
+- fix: improve auto compaction strategy @laststylebender14 (#937)
+- fix: log request headers for debugging purposes @tusharmath (#977)
+
+- refactor: update trait usage in services @ssddOnTop (#980)
+- refactor: update UI initialization to use a function for API creation @tusharmath (#982)
+- refactor: drop infrastructure trait @ssddOnTop (#979)
+- chore: add logging for request headers in chat and model fetching @tusharmath (#978)
+- refactor: update ExecutionResult to use structured input and output types @ssddOnTop (#975)
+
+---
+
+## v0.96.0​
+
+- refactor: ensure completion tool is available to all agents @tusharmath (#968)
+- feat: add support to configure max_tokens @tusharmath (#969)
+
+- refactor: add automatic subscription for agents @tusharmath (#971)
+- fix: update agents on model change @laststylebender14 (#970)
+
+- refactor: ensure completion tool is available to all agents @tusharmath (#968)
+
+---
+
+## v0.95.0​
+
+- fix: input title format to handle summaries differently @tusharmath (#957)
+- refactor(ui): implement InputTitle trait and enhance tool formatting display @tusharmath (#955)
+
+- feat: implement file size limit for read operations @ssddOnTop (#954)
+- fix: file read range limits @tusharmath (#963)
+- feat: implement FormatOutput trait and enhance logging for tool execution @tusharmath (#960)
+- feat: ability to define timeout config in Env @ssddOnTop (#958)
+- fix: implement retryable error handling for tool call parse failures @ssddOnTop (#942)
+- feat: allow agents to be tools @laststylebender14 (#927)
+- feat: load user specified templates @laststylebender14 (#939)
+- fix: add max_read_size configuration to env @ssddOnTop (#943)
+- feat: add support for skipping lines in fs_search @ssddOnTop (#925)
+- refactor: use registry v2 instead of tool service @ssddOnTop (#933)
+- refactor: update agent names to Forge and Fuse @laststylebender14 (#930)
+- feat: add title and desc to agent @laststylebender14 (#929)
+- feat: allow user to select agents interactively @laststylebender14 (#919)
+- refactor: drop Tool dependency from MCP @ssddOnTop (#926)
+- chore: add tests for ToolOutput creation @ssddOnTop (#922)
+- refactor: add agent validation for available tools @ssddOnTop (#921)
+- feat: add cached tokens stats in info command @laststylebender14 (#896)
+- refactor: add McpService integration to ForgeServices and ToolRegistry @ssddOnTop (#916)
+- feat: add support for parallel tool calls for sonnet-4 @laststylebender14 (#884)
+- fix(domain): improve compaction for models that don't support tool calls @tusharmath (#908)
+- feat(fs): enhance file removal UX with improved path formatting and visual feedback @tusharmath (#903)
+
+- fix: correct displayed lines count in execution result @ssddOnTop (#962)
+- fix: file read range limits @tusharmath (#963)
+- fix: undo operation @tusharmath (#959)
+- fix: write an error on fs create failure @ssddOnTop (#951)
+- fix: shell output truncation @ssddOnTop (#936)
+- fix: implement retryable error handling for tool call parse failures @ssddOnTop (#942)
+- fix: interrupt for xml only when tool call is not supported @laststylebender14 (#949)
+- fix: update conversation on each turn @laststylebender14 (#947)
+- fix: update error handling to use XML formatting for ToolOutput @ssddOnTop (#940)
+- fix: update command aliases to use intuitive names for forge and muse agents @tusharmath (#935)
+- refactor: add XML formatting and truncation @ssddOnTop (#923)
+- fix: use XML based format for attachments @tusharmath (#928)
+- fix: autocompletion for empty string input @ssddOnTop (#918)
+- fix(domain): improve compaction for models that don't support tool calls @tusharmath (#908)
+- refactor: extract application layer into forge_app crate and improve reliability @tusharmath (#902)
+- fix: handle UTF-8 character boundaries in SearchTerm processing (#888) @echozyr2001 (#891)
+- refactor(retry): consolidate retry logic and improve error handling system @tusharmath (#901)
+- fix: apply middle out transform @laststylebender14 (#895)
+- fix: improve conversation context compaction by including user messages in sequence detection @tusharmath (#885)
+- fix: make name and command_or_url required in McpAddArgs @amitksingh1490 (#883)
+- fix(doc): improve documentation for file reading functionality and clarify usage @tusharmath (#881)
+- fix(retry): enhance error detection with recursive checking and comprehensive tests @tusharmath (#880)
+
+- chore: upgrade shell truncated output formatting @ssddOnTop (#966)
+- chore: rename tools module in services @tusharmath (#964)
+- fix: undo operation @tusharmath (#959)
+- feat: implement FormatOutput trait and enhance logging for tool execution @tusharmath (#960)
+- refactor: implement executor pattern for tool call handling and enhance input title formatting @tusharmath (#956)
+- refactor: remove unused Tool references and commented-out find method @tusharmath (#953)
+- refactor: remove old tools @tusharmath (#952)
+- chore: avoid sending file content back to LLM while creating file @ssddOnTop (#950)
+- chore: drop tool based events from chat response @laststylebender14 (#945)
+- refactor: move retry logic from domain to app layer for better separation of concerns @tusharmath (#948)
+- refactor: format HTML output for better readability in Element rendering @tusharmath (#944)
+- refactor: improve tool call context message @ssddOnTop (#941)
+- refactor: update merge strategies for tools and subscribe fields in Agent struct @tusharmath (#934)
+- chore: drop display path from services @ssddOnTop (#932)
+- refactor: add XML formatting and truncation @ssddOnTop (#923)
+- refactor: update agent names to Forge and Fuse @laststylebender14 (#930)
+- refactor: use XML to format tool output @tusharmath (#924)
+- chore: add tests for ToolOutput creation @ssddOnTop (#922)
+- refactor: add agent validation for available tools @ssddOnTop (#921)
+- refactor: swap tool call implementation to forge_app @ssddOnTop (#920)
+- refactor: add tool_definition to forge_domain::tools @ssddOnTop (#915)
+- refactor: Implement services for each tool @ssddOnTop (#913)
+- chore: implement ToolRegistry and integrate into ForgeApp @ssddOnTop (#911)
+- refactor(fs): migrate file reading from character-based to line-based indexing @tusharmath (#907)
+- refactor: extract application layer into forge_app crate and improve reliability @tusharmath (#902)
+- chore: send conversation id to forge provider @laststylebender14 (#904)
+- feat(fs): enhance file removal UX with improved path formatting and visual feedback @tusharmath (#903)
+- refactor(agent): remove unused fields and improve context compaction with template system @tusharmath (#899)
+- fix: apply middle out transform @laststylebender14 (#895)
+- refactor(agent): simplify context initialization and remove ephemeral field @tusharmath (#893)
+- refactor(orchestrator): major rewrite with template system and integrated context compaction @tusharmath (#886)
+- refactor(tests): streamline sequence finding tests and improve coverage @tusharmath (#882)

homelab/raw/articles/forge/reference/releases-2025-March.md

@@ -0,0 +1,458 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/releases/2025/March/
+scraped: 2026-04-28T21:02:28.690605+00:00
+content_hash: 71e96e9e
+---
+# March
+
+Update to latest version !!
+Get the instructions from the docs
+[Get Started](https://forgecode.dev/docs/)
+## v0.53.3​
+
+### 🐛 Bug Fixes​
+
+- fix: ensure URLs end with a trailing slash in Provider methods @Kaushal-26 (#601)
+
+---
+
+## v0.53.2​
+
+- fix: Implement retry mechanism with exponential backoff for agent @amitksingh1490 (#570)
+
+---
+
+## v0.53.1​
+
+- fix: cargo test failing @laststylebender14 (#597)
+
+---
+
+## v0.53.0​
+
+### 🚀 Features​
+
+- feat: Implement automatic context compaction for improved conversation management @tusharmath (#582)
+
+---
+
+## v0.52.2​
+
+- fix: update X-Title header and add HTTP-Referer @amitksingh1490 (#594)
+
+### 🧰 Maintenance​
+
+- refactor: change Event value type to serde value @laststylebender14 (#592)
+
+---
+
+## v0.52.1​
+
+- fix: attachment utf-8 parsing @laststylebender14 (#593)
+
+- refactor: change Event value type to serde value @laststylebender14 (#592)
+
+---
+
+## v0.52.0​
+
+- feat: configure temperature agent wise @laststylebender14 (#591)
+
+---
+
+## v0.51.8​
+
+- fix: show forbidden and too many requests on cli error @amitksingh1490 (#589)
+
+---
+
+## v0.51.7​
+
+- fix: patched files result to return content @amitksingh1490 (#588)
+
+---
+
+## v0.51.6​
+
+- fix: parsing error on models response @amitksingh1490 (#586)
+
+---
+
+## v0.51.5​
+
+- fix: propagate prompt errors @tusharmath (#583)
+
+---
+
+## v0.51.4​
+
+- refactor: Rename modules @tusharmath (#577)
+
+- fix: update output format for patched files to include status indication @amitksingh1490 (#581)
+
+---
+
+## v0.51.3​
+
+- fix: avoid unwrapping when receiver is dropped. @laststylebender14 (#568)
+
+---
+
+## v0.51.2​
+
+- fix(#561): Redesign conversation state management to address agent persistence after interruptions @tusharmath (#565)
+
+---
+
+## v0.51.1​
+
+- fix: Update message sending logic to include Custom type responses @amitksingh1490 (#562)
+
+---
+
+## v0.51.0​
+
+- feat: add Terminal Markdown Display @tusharmath (#557)
+
+### 📝 Documentation​
+
+- feat: add Terminal Markdown Display @tusharmath (#557)
+
+- feat: add Terminal Markdown Display @tusharmath (#557)
+
+---
+
+## v0.50.0​
+
+- feat: add show_user tool, refactor FSRead, and improve Agent event handling @tusharmath (#556)
+
+- feat: add show_user tool, refactor FSRead, and improve Agent event handling @tusharmath (#556)
+
+---
+
+## v0.49.0​
+
+- fix: merge strategy for agent subscriptions @tusharmath (#554)
+
+- fix: merge strategy for agent subscriptions @tusharmath (#554)
+
+---
+
+## v0.48.0​
+
+- feat: Add agent disable functionality and enhance command handling @tusharmath (#551)
+
+- chore(ci): simplify forge event JSON by removing comment body from re… @amitksingh1490 (#548)
+- chore(ci): escape special characters in forge event JSON string @amitksingh1490 (#547)
+- chore(ci): JSON parsing error with special characters in comments @amitksingh1490 (#546)
+
+---
+
+## v0.47.3​
+
+- docs: add NPM installation instructions to README.md @amitksingh1490 (#534)
+
+- fix: update GitHub agent configurations @amitksingh1490 (#542)
+
+---
+
+## v0.47.2​
+
+- fix: improve git commit prompt to handle staged changes better @tusharmath (#533)
+
+- fix: improve git commit prompt to handle staged changes better @tusharmath (#533)
+
+---
+
+## v0.47.1​
+
+- fix: enhance PLAN mode guidelines to prohibit code snippets in favor of conceptual descriptions @tusharmath (#535)
+
+---
+
+## v0.47.0​
+
+- feat: add npm package publishing to CI workflow @amitksingh1490 (#529)
+
+---
+
+## v0.46.2​
+
+- fix(531): handle empty content error in streaming response @rahulkadam (#532)
+
+- chore(deps): bump ring from 0.17.8 to 0.17.13 @dependabot[bot] (#473)
+
+---
+
+## v0.46.1​
+
+- fix(templates): enhance PR template with GitHub CLI integration and system info partials @tusharmath (#530)
+
+---
+
+## v0.46.0​
+
+- feat(provider): add support for anthropic_url @tusharmath (#527)
+
+---
+
+## v0.45.0​
+
+- feat: add current date to system context and templates @tusharmath (#525)
+
+---
+
+## v0.44.0​
+
+- fix: snapshot creation for new files @tusharmath (#524)
+
+- fix: snapshot creation for new files @tusharmath (#524)
+
+---
+
+## v0.43.2​
+
+- fix(prompt): version format in prompt @tusharmath (#521)
+
+---
+
+## v0.43.1​
+
+- fix: simplify title generation event logic @tusharmath (#520)
+
+---
+
+## v0.43.0​
+
+- fix: reduce snapshot API surface @ssddOnTop (#495)
+
+- fix: reduce snapshot API surface @ssddOnTop (#495)
+
+---
+
+## v0.42.1​
+
+- fix: improve help prompts @tusharmath (#519)
+
+- fix: improve help prompts @tusharmath (#519)
+
+---
+
+## v0.42.0​
+
+- feat: allow support for registering custom commands @laststylebender14 (#503)
+
+- chore(ci): exclude bot from triggering PR updates in Forge automation @amitksingh1490 (#514)
+- chore(ci): update GitHub Actions to use generated token for issue and… @amitksingh1490 (#512)
+- chore(ci): update GitHub Actions to use generated token for issue and PR comments @amitksingh1490 (#511)
+
+---
+
+## v0.41.0​
+
+- chore(ci): add comments to issues and PRs with action links in Forge @amitksingh1490 (#509)
+
+- fix: add Markdown file requirements for PLAN mode @tusharmath (#508)
+
+- chore(ci): add comments to issues and PRs with action links in Forge @amitksingh1490 (#509)
+
+---
+
+## v0.40.1​
+
+- fix(ci): update Forge CLI commands to use --event parameter for issue processing @amitksingh1490 (#505)
+
+- chore(ci): add Forge Automation workflow @amitksingh1490 (#504)
+
+---
+
+## v0.40.0​
+
+- feat(CLI): add --event parameter to dispatch custom events @amitksingh1490 (#499)
+
+- feat(CLI): add --event parameter to dispatch custom events @amitksingh1490 (#499)
+
+---
+
+## v0.39.0​
+
+- feat: use queue based system for agents @laststylebender14 (#494)
+
+---
+
+## v0.38.1​
+
+- fix(open_router): replace OpenAITransformer with DropOpenRouterFields and remove redundant logging @tusharmath (#502)
+
+---
+
+## v0.38.0​
+
+- fix(provider): improve Open AI compatibility and error handling @tusharmath (#496)
+
+- fix(provider): improve Open AI compatibility and error handling @tusharmath (#496)
+
+---
+
+## v0.37.0​
+
+- feat: add support for project level rules. @laststylebender14 (#487)
+
+---
+
+## v0.36.2​
+
+- feat(config): support workflow merge @tusharmath (#478)
+
+---
+
+## v0.36.1​
+
+- fix(ui): integrate tracker dispatch for prompt events in user input handling @amitksingh1490 (#479)
+
+---
+
+## v0.36.0​
+
+- feat: implement file snapshot system @ssddOnTop (#457)
+
+- fix: set forge_fs and forge_walker to workspace @ssddOnTop (#481)
+
+- chore: update Rust edition from 2024 to 2021 in Cargo.toml @amitksingh1490 (#480)
+
+---
+
+## v0.35.0​
+
+- feat: add help command mode with dedicated help agent @tusharmath (#475)
+
+---
+
+## v0.34.0​
+
+- feat(tools): introduce agent-level tool support configuration @tusharmath (#476)
+
+---
+
+## v0.33.0​
+
+- feat(provider): add support for custom provider URLs @tusharmath (#474)
+
+- doc: add application logs documentation to README @tusharmath (#470)
+
+- chore: move dependencies to root Cargo.toml @ssddOnTop (#471)
+
+---
+
+## v0.32.1​
+
+- fix: change logging format to json @tusharmath (#469)
+
+---
+
+## v0.32.0​
+
+- fix: separate default forge config from user config @tusharmath (#466)
+
+- fix(auth): simplify provider handling with URL-based configuration @tusharmath (#465)
+- Revert "feat(oauth): implement authentication flow with login and logout" @tusharmath (#464)
+
+- fix(auth): simplify provider handling with URL-based configuration @tusharmath (#465)
+
+---
+
+## v0.31.0​
+
+- fix(auth): simplify provider handling with URL-based configuration @tusharmath (#465)
+- Revert "feat(oauth): implement authentication flow with login and logout" @tusharmath (#464)
+- feat(oauth): implement authentication flow with login and logout @amitksingh1490 (#442)
+
+- fix(auth): simplify provider handling with URL-based configuration @tusharmath (#465)
+
+---
+
+## v0.30.0​
+
+- feat: Add Act and Plan modes @tusharmath (#460)
+
+- feat: Add Act and Plan modes @tusharmath (#460)
+
+---
+
+## v0.29.3​
+
+- fix(prompt): enhance user collaboration and feedback workflow @tusharmath (#458)
+
+---
+
+## v0.29.2​
+
+- fix: system prompt improvements and shell tool formatting @tusharmath (#453)
+
+---
+
+## v0.29.1​
+
+- fix: improve error handling for tool call parsing @tusharmath (#447)
+
+- refactor: migrate from content-based to event-based communication model @tusharmath (#446)
+
+---
+
+## v0.29.0​
+
+- feat(patch): support multiple-patch operations in a single call @tusharmath (#445)
+
+- feat(patch): support multiple-patch operations in a single call @tusharmath (#445)
+
+---
+
+## v0.28.2​
+
+- fix: version in /info @ssddOnTop (#444)
+
+---
+
+## v0.28.1​
+
+- fix: add diff output display to apply_json.rs @tusharmath (#443)
+
+---
+
+## v0.28.0​
+
+- chore: add nextest.toml configuration for test timeouts @tusharmath (#438)
+
+- feat: ability to attach images @ssddOnTop (#378)
+- feat: display Version in /info @ssddOnTop (#434)
+
+- fix: Make walker depth optional and more flexible in template agent @tusharmath (#431)
+
+- chore: ability to disable test_find_cat_name @ssddOnTop (#441)
+- fix: Make walker depth optional and more flexible in template agent @tusharmath (#431)
+
+---
+
+## v0.27.0​
+
+- refactor: Make system_prompt and user_prompt fields optional for agents @tusharmath (#418)
+
+- feat(fs-patch): replace fuzzy patching with operation-based exact patching @tusharmath (#429)
+- feat(template): add agent reference to template service @tusharmath (#427)
+
+- fix: replace OPEN_ROUTER_KEY with OPENROUTER_API_KEY @DrSensor (#425)
+
+---
+
+## v0.26.0​
+
+- feat: add overwrite option to FSWriteInput for file writing behavior @tusharmath (#417)
+
+- docs: add Discord community section to README with invitation and badge @amitksingh1490 (#412)
+- docs: streamline README by removing outdated API key section and enhancing feature descriptions @amitksingh1490 (#396)
+
+- Rename DispatchEvent to Event @tusharmath (#410)
+
+- refactor: Move Provider tests to forge_infra with sequential execution @tusharmath (#414)

homelab/raw/articles/forge/reference/releases-2025-May.md

@@ -0,0 +1,265 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/releases/2025/May/
+scraped: 2026-04-28T21:02:18.353781+00:00
+content_hash: 6e8d5702
+---
+# May
+
+Update to latest version !!
+Get the instructions from the docs
+[Get Started](https://forgecode.dev/docs/)
+## v0.94.5​
+
+### 🐛 Bug Fixes​
+
+- fix: remove assignment of top_p in Open AI transformer @amitksingh1490 (#876)
+- fix(ui): resolve spinner display issues and redundant stop calls @tusharmath (#875)
+- fix: ensure completion tool output is recorded and all tool results are captured @tusharmath (#874)
+
+### 🧰 Maintenance​
+
+- chore: update the explanation description @laststylebender14 (#871)
+
+---
+
+## v0.94.4​
+
+- feat: add top_p and top_k parameters for AI model configuration @tusharmath (#861)
+
+- fix: error message format for tracing @tusharmath (#867)
+- fix(error): improve error formatting for Retryable variant @tusharmath (#866)
+- fix(ui): add spinner feedback during conversation initialization @tusharmath (#862)
+
+- chore: add explanation field to forge tools @ssddOnTop (#868)
+- chore: add versioning to client headers for better tracking @ssddOnTop (#863)
+- chore: collect LLM response message @tusharmath (#865)
+- chore: add more tracing @ssddOnTop (#860)
+
+---
+
+## v0.94.2​
+
+- fix: image handling in tool API @tusharmath (#859)
+
+- refactor: update token estimation logic and enhance usage struct with content length @tusharmath (#857)
+
+---
+
+## v0.94.1​
+
+- fix(model): change supported_parameters to be optional @tusharmath (#856)
+
+---
+
+## v0.94.0​
+
+### 🚀 Features​
+
+- fix: token usage computation @tusharmath (#855)
+- feat: utilise tool supported setting from api @laststylebender14 (#846)
+
+- fix(tools): return error to agent instead of raising exception @laststylebender14 (#845)
+- fix: standardize error output using eprintln instead of println @tusharmath (#852)
+- fix(domain): resolve serde deserialization errors for conversation loading @ssddOnTop (#849)
+- fix: avoid caching models on ui @laststylebender14 (#847)
+- fix(ui): align tool numbering with consistent padding @amitksingh1490 (#835)
+- fix: execute shell commands correctly @laststylebender14 (#825)
+
+- fix: token usage computation @tusharmath (#855)
+- chore(tracking): track warnings and info messages @tusharmath (#854)
+- chore(conversation): add All Subscriptions section to HTML rendering @tusharmath (#853)
+- chore: added conversation to error context @ssddOnTop (#839)
+
+---
+
+## v0.93.0​
+
+- fix(ui): add spinners for custom commands @tusharmath (#834)
+
+- fix: force update of @antinomyhq/forge package in execute_update_command @ssddOnTop (#841)
+- fix(provider): improve error handling for stream termination and API responses @tusharmath (#840)
+- fix: add cache control only for the models that supports it @laststylebender14 (#836)
+- fix(ui): ensure command registration occurs after workflow initialization @tusharmath (#831)
+- fix(mcp): change atomic ordering from SeqCst to Relaxed for reconnect logic @tusharmath (#829)
+- fix: .mcp.json deserialization @ssddOnTop (#828)
+
+- refactor: update ExecutableTool interface to return ToolContent instead of String @tusharmath (#832)
+- chore: drop Optional fields in Mcp Servers @ssddOnTop (#830)
+- fix: .mcp.json deserialization @ssddOnTop (#828)
+
+---
+
+## v0.92.0​
+
+- feat(mcp): add support for mcp via .mcp.json @ssddOnTop (#797)
+
+- fix: implement retry at orch level @laststylebender14 (#824)
+- fix: improve agent interaction with completion feedback @tusharmath (#820)
+- fix(domain): ensure workflow model updates agent compaction configurations @tusharmath (#818)
+
+- chore: rename open router to antinomy @laststylebender14 (#819)
+
+---
+
+## v0.91.0​
+
+- feat: use raw command api for command execution @laststylebender14 (#816)
+
+- fix: infinite spinner unstable internet @ssddOnTop (#810)
+- fix: auto update @laststylebender14 (#813)
+- fix: correct release ID reference in CI workflow @tusharmath (#815)
+- fix: app version @tusharmath (#814)
+- fix: application version @tusharmath (#812)
+
+---
+
+## v0.90.1​
+
+- fix: CI improvements @tusharmath (#811)
+
+---
+
+## v0.90.0​
+
+- feat: support environment variables across directory hierarchy @ssddOnTop (#803)
+
+- fix: consolidate question handling into forge_tool_attempt_completion @tusharmath (#807)
+- fix: correct tag in usage instructions for Completion tool @tusharmath (#806)
+- feat: persist mode in forge.yaml @laststylebender14 (#793)
+- fix: quotation issues in windows @ssddOnTop (#805)
+- fix: include tool description in schema @tusharmath (#800)
+
+- chore: store model ID with each conversation message @tusharmath (#808)
+- chore: update antinomy.ai links in README @laststylebender14 (#802)
+
+---
+
+## v0.89.0​
+
+- feat: add update functionality on startup and an update command for manual updates @iambenkay (#720)
+
+- fix: improve error diagnostics and file operation feedback @tusharmath (#799)
+
+- chore: track model across all events @laststylebender14 (#796)
+
+---
+
+## v0.87.4​
+
+- fix: support large fs_find operations @laststylebender14 (#766)
+- fix: compaction spinner fixes and interrupt handling @tusharmath (#783)
+- fix: compaction spinner updates and interruption @laststylebender14 (#775)
+- fix: support large shell command outputs @laststylebender14 (#748)
+- fix: optimise completion tool prompts @laststylebender14 (#768)
+- fix: add forge_tool_attempt_completion to software-designer agent's tools @amitksingh1490 (#777)
+
+- refactor(domain): standardize tool input types across services @tusharmath (#788)
+
+---
+
+## v0.87.2​
+
+- fix: update CI workflow to trigger on tag pushes and update dependenc… @amitksingh1490 (#776)
+- fix: update CI workflow to trigger on tag pushes instead of main branch @amitksingh1490 (#773)
+
+---
+
+## v0.87.1​
+
+- fix: update CI workflow to trigger on tag pushes instead of main branch @amitksingh1490 (#773)
+- fix: add range support for fetch tool @laststylebender14 (#745)
+
+---
+
+## v0.87.0​
+
+- fix: never reveal tool name to user @laststylebender14 (#764)
+
+- fix: never reveal tool name to user @laststylebender14 (#764)
+- fix: allow multiline pastes @laststylebender14 (#760)
+
+---
+
+## v0.86.0​
+
+- feat: allow search tool to accept file path to search in @laststylebender14 (#758)
+
+---
+
+## v0.85.3​
+
+- fix: zero usage @laststylebender14 (#751)
+
+---
+
+## v0.85.2​
+
+- fix: zero usage @laststylebender14 (#751)
+- fix(markdown): add dim attribute to code block style for better visibility @tusharmath (#752)
+
+---
+
+## v0.85.1​
+
+- fix(tools): update tool names to use consistent naming convention @tusharmath (#749)
+
+---
+
+## v0.85.0​
+
+- fix(tools): use JsonSchema instead of XML to Parse Tools @tusharmath (#739)
+
+- fix(tools): use JsonSchema instead of XML to Parse Tools @tusharmath (#739)
+
+---
+
+## v0.84.0​
+
+- feat: ensure agent doesn't quit in-between task @laststylebender14 (#734)
+
+---
+
+## v0.83.2​
+
+- fix: remove duplicate tool call params from result @laststylebender14 (#738)
+
+---
+
+## v0.83.1​
+
+- fix: fs tool usage prompt to include the correct calculation @laststylebender14 (#737)
+
+---
+
+## v0.83.0​
+
+- feat: add keep_ansi flag to shell tool @akmane-96 (#732)
+
+---
+
+## v0.82.0​
+
+- feat: add keep_ansi flag to shell tool @akmane-96 (#732)
+- feat: add provider in /info @akmane-96 (#722)
+
+---
+
+## v0.81.0​
+
+- feat: add token estimation feature @luffy-orf (#715)
+
+---
+
+## v0.80.1​
+
+- fix(tools): image support + error on requesting a large range @tusharmath (#726)
+
+---
+
+## v0.80.0​
+
+- feat(workflow): implement config file search in parent directories @tusharmath (#729)
+
+- fix(tracker): track toolcall usage @laststylebender14 (#731)

homelab/raw/articles/forge/reference/releases-2025-October.md

@@ -0,0 +1,219 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/releases/2025/October/
+scraped: 2026-04-28T21:02:21.863180+00:00
+content_hash: dd8246b6
+---
+# October
+
+Update to latest version !!
+Get the instructions from the docs
+[Get Started](https://forgecode.dev/docs/)
+## v1.2.0​
+
+### 🚀 Features​
+
+- feat: maintain session based isolation for agents @tusharmath (#1799)
+- feat: ability to define provider per agent @ssddOnTop (#1705)
+- feat: show conversation preview in ZSH @tusharmath (#1787)
+
+### 🐛 Bug Fixes​
+
+- fix(zsh): model and provider selection @amitksingh1490 (#1806)
+- fix: ensure deterministic first provider selection @amitksingh1490 (#1805)
+- fix: allow empty json object in mcp json file @laststylebender14 (#1804)
+- refactor: global agent config fixed @tusharmath (#1795)
+- fix: sub-agent calls @tusharmath (#1796)
+
+### 🧰 Maintenance​
+
+- refactor: simplify config set command handling by consolidating field updates @tusharmath (#1798)
+- refactor: global agent config fixed @tusharmath (#1795)
+- refactor: remove subscription from agents @tusharmath (#1794)
+- chore: improve conversation switching message @tusharmath (#1791)
+
+---
+
+## v1.1.0​
+
+- feat: show user feedback and task in summary @tusharmath (#1786)
+- fix: make info key col fixed width @tusharmath (#1784)
+- feat: support custom providers and models @tusharmath (#1777)
+- feat: show user task @tusharmath (#1781)
+- feat: add completion prompt toggle via environment variable @laststylebender14 (#1733)
+
+- fix: show correct title for write tool operations @laststylebender14 (#1783)
+- fix: make info key col fixed width @tusharmath (#1784)
+- fix: mcp import accepts JSON in invalid format @ssddOnTop (#1779)
+
+### 🚀 Performance​
+
+- perf: make read operation output consistent across tools @laststylebender14 (#1790)
+
+- feat: support custom providers and models @tusharmath (#1777)
+
+---
+
+## v1.0.0​
+
+- feat: ability to define commands in MD @ssddOnTop (#1708)
+- feat: ability to read images via tools @ssddOnTop (#1710)
+- feat: ability to disable mcp servers @ssddOnTop (#1748)
+- feat: update CLI commands @amitksingh1490 (#1669)
+
+- fix: adjust porcelain display to skip two entries @amitksingh1490 (#1773)
+- fix: porcelain mode display errors @amitksingh1490 (#1769)
+- fix: /compact command @laststylebender14 (#1744)
+- fix: allow reasoning even after compaction @laststylebender14 (#1749)
+- fix: exit condition for agentic loop @laststylebender14 (#1770)
+- fix: normalize image path @laststylebender14 (#1766)
+- fix: handle varying row length in porcelain format @tusharmath (#1764)
+- fix: improve fs patch performance @laststylebender14 (#1759)
+- fix: handle relative paths for all tools @laststylebender14 (#1758)
+- fix: reorder key-value pairs in conversation info display @amitksingh1490 (#1747)
+- fix: improve model information @amitksingh1490 (#1746)
+- fix: tool calls to agent @laststylebender14 (#1742)
+- fix: persist metrics tracking @tusharmath (#1739)
+- fix: Handle invalid JSON in tool calls for anthropic provider @tusharmath (#1741)
+- fix: allow support for reading multiline env vars @laststylebender14 (#1738)
+
+- fix: improve fs patch performance @laststylebender14 (#1759)
+
+- chore: simplify config command handling @amitksingh1490 (#1772)
+- refactor: use faker to generate env in tests @tusharmath (#1767)
+- chore: refactor config field handling to use enum for better type safety @tusharmath (#1771)
+- chore: update clippy targets @ssddOnTop (#1765)
+- chore: update container image @tusharmath (#1760)
+
+### 💥 Breaking Changes​
+
+- feat: update CLI commands @amitksingh1490 (#1669)
+
+---
+
+## v0.126.0​
+
+- feat: add FORGE_MAX_CONVERSATIONS env variable @tusharmath (#1726)
+- feat: make banner configurable via env variable @laststylebender14 (#1723)
+- feat: add delete option in patch @tusharmath (#1713)
+
+- fix: silence MCP logs by redirecting stderr to null @amitksingh1490 (#1732)
+- fix: use compatible provider for OpenAI and Anthropic urls @tusharmath (#1731)
+- fix: handle conversation loading in headless mode @laststylebender14 (#1724)
+- fix: make title generation async @tusharmath (#1719)
+- fix: improve OpenAI and Anthropic compatible provider types @manthanabc (#1718)
+- fix: handle newlines better with delete operation in patch @tusharmath (#1714)
+
+- fix: use compatible provider for OpenAI and Anthropic urls @tusharmath (#1731)
+- chore: clean up ui @laststylebender14 (#1722)
+- chore: trace file reading errors @ssddOnTop (#1717)
+
+---
+
+## v0.125.1​
+
+- fix: Update compact.rs and forge.default.yaml @amitksingh1490 (#1701)
+- fix: show output of overwrite @tusharmath (#1700)
+- fix: handle invalid app config gracefully @amitksingh1490 (#1699)
+- fix: add more non_negotiable_rules @laststylebender14 (#1694)
+- fix: dedupe tool definition sent to upstream @laststylebender14 (#1693)
+
+- refactor: drop attempt-completion @tusharmath (#1696)
+- chore: update rmcp version @amitksingh1490 (#1690)
+
+---
+
+## v0.125.0​
+
+- Revert "feat: add Github provider" @amitksingh1490 (#1695)
+
+---
+
+## v0.124.0​
+
+- feat: add Github provider @tusharmath (#1689)
+- feat: add Azure provider support with URL construction and configuration @amitksingh1490 (#1679)
+
+- fix: enhance MCP server handling with failure tracking @amitksingh1490 (#1684)
+
+- perf: make zsh lazily initialized @tusharmath (#1692)
+
+---
+
+## v0.123.3​
+
+- fix: accumulate usage from summarization in context @amitksingh1490 (#1666)
+- fix: remove unnecessary search output from CLI @tusharmath (#1678)
+- fix: skip empty messages from user logs @tusharmath (#1676)
+- fix: agent ID retrieval in tools command @amitksingh1490 (#1677)
+
+---
+
+## v0.123.2​
+
+- fix: revert FORGE_BIN to default 'forge' for consistency @amitksingh1490 (#1672)
+- fix: add Z.ai thinking transformation @amitksingh1490 (#1673)
+- fix: add reasoning configuration and styles to conversation rendering @amitksingh1490 (#1667)
+
+---
+
+## v0.123.1​
+
+- fix: improve ZSH experience @tusharmath (#1660)
+- fix: improve reliability of mcp on ZSH @amitksingh1490 (#1661)
+- fix: tool validation to support glob patterns @amitksingh1490 (#1663)
+- fix: order of conversation by updated_at @tusharmath (#1662)
+
+---
+
+## v0.123.0​
+
+- feat: persist provider specific model @tusharmath (#1647)
+
+- feat: add BigModel provider @ssddOnTop (#1658)
+- feat: support glob patterns for MCP tool access @tusharmath (#1652)
+- feat: add 'show-tools' command and update zsh plugin @amitksingh1490 (#1651)
+- feat: add session management commands for handling conversations @amitksingh1490 (#1643)
+- feat: implement configuration management commands @amitksingh1490 (#1623)
+
+- fix: empty app config @ssddOnTop (#1659)
+- fix: correct command references from "/conversations" to "/conversation" @amitksingh1490 (#1653)
+- fix: derive cost from cost_details @laststylebender14 (#1646)
+- fix: raise an error if no provider is configured. @laststylebender14 (#1645)
+
+- chore: rename .json file @tusharmath (#1655)
+- refactor: move model configuration into a JSON file @tusharmath (#1650)
+- chore: update dependencies and features for multiple crates @amitksingh1490 (#1627)
+
+---
+
+## v0.122.2​
+
+- fix: ensure tool_supported is explicitly set in configuration @tusharmath (#1639)
+
+- refactor: improve title formatting in conversation initialization @tusharmath (#1637)
+- chore: update action trigger @tusharmath (#1638)
+- refactor: have single source of truth @tusharmath (#1630)
+- refactor: remove redundant explanation fields from tool input structs @tusharmath (#1636)
+
+---
+
+## v0.122.1​
+
+- revert: 1597 @amitksingh1490 (#1624)
+
+- chore(deps): bump the actions group with 2 updates @dependabot[bot] (#1610)
+
+---
+
+## v0.122.0​
+
+- feat: add :info command in zsh @tusharmath (#1614)
+- feat: support for provider selection @tusharmath (#1603)
+
+- fix: handle diff for large file formats @tusharmath (#1621)
+- fix: enhance token calculation in Usage struct to include cache read @amitksingh1490 (#1622)
+- fix: use configurable fd command for file searching in completion @tusharmath (#1618)
+- fix: make client cache provider specific @tusharmath (#1617)
+- fix(zsh): empty prompts will set the agent @tusharmath (#1613)

homelab/raw/articles/forge/reference/releases-2025-September.md

@@ -0,0 +1,209 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/releases/2025/September/
+scraped: 2026-04-28T21:02:42.317126+00:00
+content_hash: a6b91810
+---
+# September
+
+Update to latest version !!
+Get the instructions from the docs
+[Get Started](https://forgecode.dev/docs/)
+## v0.121.1​
+
+### 🐛 Bug Fixes​
+
+- fix: support for STDIN via ZSH @tusharmath (#1606)
+- fix: add only files in system prompt @laststylebender14 (#1608)
+
+### 🧰 Maintenance​
+
+- chore: setup default active agent @tusharmath (#1611)
+- refactor: drop prime and parker @tusharmath (#1609)
+- fix: support for STDIN via ZSH @tusharmath (#1606)
+
+---
+
+## v0.121.0​
+
+### 🚀 Features​
+
+- feat: add OpenAI responses API support for GPT-5 models @sebyx07 (#1597)
+
+- fix: many fixes @tusharmath (#1604)
+- fix(zsh): unset user action @tusharmath (#1600)
+- fix(zsh): handle CTRL+C better @tusharmath (#1601)
+- fix: sort tools by name @tusharmath (#1599)
+
+- chore: improve ZSH compatibility @tusharmath (#1591)
+
+---
+
+## v0.120.1​
+
+- fix: rename current_time to current_date for consistency @laststylebender14 (#1584)
+- fix: load usage from conversions when used with cli commands @laststylebender14 (#1575)
+- fix: enhance SQLite connection configuration for better concurrency @laststylebender14 (#1583)
+
+---
+
+## v0.120.0​
+
+- feat: add ZLE widget to toggle conversation pattern in input buffer @tusharmath (#1571)
+
+- fix: minor ZSH plugin improvements @tusharmath (#1581)
+- fix: load usage from conversation @laststylebender14 (#1574)
+- fix: reset resume on /new @tusharmath (#1576)
+- fix: refine wording in research question handling instructions @tusharmath (#1573)
+
+---
+
+## v0.119.1​
+
+- fix: unexpected tool call failure limits being hit @tusharmath (#1570)
+
+---
+
+## v0.119.0​
+
+- feat: show conversation id in /info @tusharmath (#1554)
+
+- fix: don't exit on an invalid command @laststylebender14 (#1569)
+- fix: save forked conversations in database. @laststylebender14 (#1568)
+
+---
+
+## v0.118.0​
+
+- feat: add support for Vertex AI provider and models @amitksingh1490 (#1553)
+
+- fix: toolcall error count @tusharmath (#1562)
+- fix: drop reasoning from title generator @laststylebender14 (#1567)
+- fix: update the plugin for append @tusharmath (#1566)
+- fix: performance improvements for compaction @tusharmath (#1565)
+- fix: improve ZSH plugin with support for file tagging and session @tusharmath (#1561)
+- fix: user prompt format @tusharmath (#1560)
+- fix: hide "new task" prompt if running in non-interactive mode @tusharmath (#1552)
+
+### 🚀 Performance​
+
+- fix: performance improvements for compaction @tusharmath (#1565)
+
+---
+
+## v0.117.0​
+
+- feat: add FORGE_HISTORY_FILE env variable @tusharmath (#1548)
+- feat: insert /agent-<agent-name> aliases @tusharmath (#1547)
+- feat: add line numbers to attachments @laststylebender14 (#1540)
+- fix: improve system prompt for muse @tusharmath (#1538)
+- feat: add FORGE_DUMP_AUTO_OPEN env variable @tusharmath (#1537)
+- feat: add support for ZAI coding plan @amitksingh1490 (#1532)
+- feat: persist conversations @laststylebender14 (#1525)
+
+- fix: improve conversation title generation @tusharmath (#1550)
+- fix: add libsqlite3-sys dependency to Cargo.toml and Cargo.lock @amitksingh1490 (#1543)
+- fix: show actual error instead of simple message @laststylebender14 (#1529)
+- fix: show attempt-completion in /tools for all agents @tusharmath (#1545)
+- fix: handle duplicated tool names @tusharmath (#1544)
+- fix: GLM caching improvements @amitksingh1490 (#1541)
+- fix: show banner in interactive mode only @laststylebender14 (#1535)
+
+- chore: disable fetching usage stats from forge @laststylebender14 (#1534)
+
+---
+
+## v0.116.0​
+
+- feat: add line number in fs_read output @laststylebender14 (#1509)
+
+- fix: duplicate mcp tool definition @tusharmath (#1527)
+- fix: match on exact subscription @laststylebender14 (#1519)
+- refactor: simplify conversation and orchestrator @tusharmath (#1513)
+
+- chore: remove unused dependencies @tusharmath (#1528)
+- chore: drop forge_main_neo @tusharmath (#1526)
+- feat: add image caching @laststylebender14 (#1442)
+- chore: update reedline version @laststylebender14 (#1524)
+- tests: add tests for reasoning @laststylebender14 (#1505)
+- refactor: simplify conversation and orchestrator @tusharmath (#1513)
+
+---
+
+## v0.115.0​
+
+- feat: support for STDIN @tusharmath (#1508)
+- feat: support project specific agents under {cwd}/.forge/agents @tusharmath (#1506)
+- feat: add support for providing env variables for shell execution @tusharmath (#1500)
+- feat: enhance agent switch message to include title if available @tusharmath (#1499)
+
+- fix: send reasoning settings to upstream @laststylebender14 (#1501)
+- chore: drop gh-workflow-tailcall and use gh-workflow directly @tusharmath (#1503)
+
+- chore: add workflow for closing stale issues and PRs @tusharmath (#1502)
+
+---
+
+## v0.114.4​
+
+- fix: update built-in agent prompt @tusharmath (#1498)
+
+---
+
+## v0.114.3​
+
+### 📝 Documentation​
+
+- fix: remove fixed models from built-in agents @tusharmath (#1497)
+
+- fix: remove fixed models from built-in agents @tusharmath (#1497)
+- fix: update interaction guidelines and streamline shell command execution instructions @tusharmath (#1496)
+
+---
+
+## v0.114.2​
+
+- fix: Improved metrics tracking behaviour on fs_undo @manthanabc (#1489)
+- fix: prevent overwriting existing agent models @tusharmath (#1494)
+- fix: improve compaction focus @tusharmath (#1493)
+
+---
+
+## v0.114.1​
+
+- fix: show attempt completion in /tools command @tusharmath (#1492)
+- fix: add HTTP status code 408 to retry status codes @tusharmath (#1490)
+- fix: adjust indentation for item display in Info struct @tusharmath (#1491)
+
+---
+
+## v0.114.0​
+
+- feat: improve tool display format @tusharmath (#1488)
+
+- fix: update tool description for file read operations @tusharmath (#1487)
+
+- fix: update tool description for file read operations @tusharmath (#1487)
+- refactor: update tool names to remove deprecated prefixes @tusharmath (#1486)
+
+- feat: improve tool display format @tusharmath (#1488)
+- refactor: update tool names to remove deprecated prefixes @tusharmath (#1486)
+- refactor: drop agents from workflow @tusharmath (#1483)
+- refactor: remove operating agents from variables @tusharmath (#1484)
+- chore: rename templates from .hbs to .md @tusharmath (#1482)
+- chore: simplify forge.yaml @tusharmath (#1481)
+
+---
+
+## v0.113.0​
+
+- feat: add HTTP client certificate configuration @sabiz (#1472)
+
+- feat: add /sage command @tusharmath (#1478)
+- feat: update token summary format @tusharmath (#1477)
+
+- fix: update citation format @tusharmath (#1476)
+
+- feat: add /sage command @tusharmath (#1478)
+- chore(deps): bump tracing-subscriber from 0.3.19 to 0.3.20 @dependabot[bot] (#1469)

homelab/raw/articles/forge/reference/releases.md

@@ -0,0 +1,80 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/releases/
+scraped: 2026-04-28T21:02:32.983100+00:00
+content_hash: 06ba358c
+---
+# November
+
+Update to latest version !!
+Get the instructions from the docs
+[Get Started](https://forgecode.dev/docs/)
+## v1.4.0​
+
+### 🚀 Features​
+
+- feat(cli): add custom command support in zsh and non interactive mode @amitksingh1490 (#1851)
+- feat: track externally modified files @laststylebender14 (#1740)
+- feat: add login, logout, and custom command support to zsh plugin @amitksingh1490 (#1859)
+- feat: add conversation cloning command @tusharmath (#1870)
+- feat: support setting conversation by id in zsh @tusharmath (#1868)
+- feat: enhance the output of :env command @tusharmath (#1867)
+- feat: convert natural language to cli command @laststylebender14 (#1822)
+- feat: create non-destructive compaction summary @tusharmath (#1810)
+- feat: implement provider logout functionality @amitksingh1490 (#1846)
+- feat: add ability to use claude subscription @amitksingh1490 (#1830)
+- feat: interactive provider onboarding @amitksingh1490 (#1812)
+- feat: enhance fzf file preview @tusharmath (#1831)
+
+### 🐛 Bug Fixes​
+
+- fix: Add OS-specific multiline shortcuts in /help command @dariuszkowalski-com (#1880)
+- fix: update dump html command @tusharmath (#1877)
+- fix: drop attachment from compaction @tusharmath (#1874)
+- fix: reset usage metrics post compaction @tusharmath (#1871)
+- fix: handle missing conversation titles gracefully in session info display @tusharmath (#1869)
+- fix: make muse non-interactive @tusharmath (#1866)
+- fix: prevent duplicate Anthropic credentials during migration @amitksingh1490 (#1860)
+- feat: create non-destructive compaction summary @tusharmath (#1810)
+- fix(zsh): syntax highlighting after paste @tusharmath (#1855)
+- fix: anthropic reasoning transformer @tusharmath (#1854)
+- fix: /compaction command @laststylebender14 (#1850)
+- fix: add ClaudeCode as seperate provider @amitksingh1490 (#1849)
+- fix: allow read tool to read invalid utf char based file @laststylebender14 (#1843)
+- fix: improve console output formatting for OAuth @amitksingh1490 (#1845)
+- fix: handle empty content @tusharmath (#1839)
+- fix: use exact match in fzf @tusharmath (#1836)
+
+### 🧰 Maintenance​
+
+- refactor: make html an optional arg @tusharmath (#1876)
+- refactor: remove command option from CLI @amitksingh1490 (#1873)
+- refactor: add timestamp support to TitleFormat for conversation replay @amitksingh1490 (#1776)
+- refactor: remove compaction prompt trails @tusharmath (#1858)
+- refactor: standardize list commands to singular with plural aliases @amitksingh1490 (#1848)
+- chore: replace globset with glob for pattern matching @amitksingh1490 (#1834)
+
+---
+
+## v1.3.0​
+
+- feat: add env command @tusharmath (#1829)
+- feat: show all user prompts in info @tusharmath (#1828)
+- feat: highlight active item in ZSH @ssddOnTop (#1802)
+- feat: show all providers configured + non configured @amitksingh1490 (#1813)
+- chore: add support for ARM android @ssddOnTop (#1788)
+- feat: show conversation info in preview @tusharmath (#1821)
+- feat: allow arguments in commands @laststylebender14 (#1721)
+
+- fix: rename session commands to conversation commands in CLI and UI @tusharmath (#1823)
+- fix: model not found for a provider defined in agent @ssddOnTop (#1811)
+- fix: attach tool definitions to context @laststylebender14 (#1809)
+
+### 🚀 Performance​
+
+- perf: avoid cloning context @laststylebender14 (#1808)
+
+- chore: add support for ARM android @ssddOnTop (#1788)
+- refactor: move repo's to domain @amitksingh1490 (#1801)
+- refactor: move system-prompt generation out of orch @laststylebender14 (#1807)

homelab/raw/articles/forge/reference/terms.md

@@ -0,0 +1,81 @@
+---
+type: agent-doc
+agent: ForgeCode
+source: https://forgecode.dev/terms/
+scraped: 2026-04-28T21:02:30.264940+00:00
+content_hash: 924f6ee8
+---
+# Fair Usage Policy
+
+## 1. API Usage Restrictions
+
+### Prohibited Uses of ForgeCode's API
+
+ForgeCode's API and services are intended to be used only by the account holder within the ForgeCode application. You may use ForgeCode for any projects, but the API cannot be used outside of the ForgeCode application.
+
+The following uses are strictly prohibited:
+
+- Using ForgeCode's API to power other applications, services, or tools
+- Integrating ForgeCode's API into third-party software
+- Reselling or redistributing access to ForgeCode's API
+- Using ForgeCode as a backend service for other applications
+
+Violation Consequences: Your account will be permanently barred with no refund provided.
+
+## 2. Account Sharing Restrictions
+
+### Personal Use Only
+
+Your ForgeCode account and any associated API keys are for your personal use only and cannot be shared with others.
+
+The following activities are strictly prohibited:
+
+- Sharing your account credentials with others
+- Allowing others to use your ForgeCode account
+- Distributing your API keys to third parties
+- Creating shared or team accounts on individual plans
+
+Violation Consequences: Your account will be immediately suspended and no refund will be provided.
+
+### Multi-Device Usage Policy
+
+Account holders may use their ForgeCode account on up to two (2) devices simultaneously, subject to the following conditions:
+
+- Both devices must be used exclusively by the account holder
+- Daily usage limits apply to the combined usage across all devices
+- Account credentials must not be shared with any third parties
+- All devices must comply with the same terms and restrictions outlined in this policy
+
+Device Limit Violation: Using your account on more than two devices constitutes a violation of our Fair Usage Policy and may result in immediate account suspension without refund.
+
+Monitoring: We monitor device usage patterns to ensure compliance with this policy.
+
+## 3. Acceptable Use
+
+### Permitted Uses
+
+The following uses are explicitly permitted for the account holder:
+
+- Using ForgeCode for any coding projects and development (personal or commercial)
+- Code generation, debugging, and refactoring within the ForgeCode application
+- Learning and educational purposes
+- Using your own API keys (BYOK) with ForgeCode for unlimited usage
+- Switching between different AI providers within ForgeCode
+
+## 4. Monitoring and Enforcement
+
+We actively monitor usage patterns to ensure compliance with our fair usage policy. Unusual usage patterns that suggest API abuse or account sharing will be investigated.
+
+We reserve the right to:
+
+- Suspend or terminate accounts that violate these terms
+- Refuse refunds for accounts terminated due to policy violations
+- Update these terms as needed to maintain fair usage
+
+## 5. Contact and Questions
+
+If you have questions about what constitutes acceptable use or need clarification on these policies, please contact our support team before proceeding.
+
+Note: These restrictions help us maintain service quality and fair access for all users. Thank you for your cooperation.
+
+Last updated: July 2025Effective date: These terms apply to all current and future ForgeCode users.