feat: migrate Forge agent to Python integration system

- Create ForgeIntegration class with custom processing for {{parameters}}, handoffs stripping, and name injection
- Add update-context scripts (bash and PowerShell) for Forge
- Register Forge in integration registry
- Update AGENTS.md with Forge documentation and special processing requirements section
- Add comprehensive test suite (11 tests, all passing)

Closes migration from release packaging to Python-based scaffolding for Forge agent.

src/specify_cli/integrations/__init__.py

@@ -53,6 +53,7 @@ def _register_builtins() -> None:
     from .codebuddy import CodebuddyIntegration
     from .copilot import CopilotIntegration
     from .cursor_agent import CursorAgentIntegration
+    from .forge import ForgeIntegration
     from .iflow import IflowIntegration
     from .junie import JunieIntegration
     from .kilocode import KilocodeIntegration
@@ -75,6 +76,7 @@ def _register_builtins() -> None:
     _register(CodebuddyIntegration())
     _register(CopilotIntegration())
     _register(CursorAgentIntegration())
+    _register(ForgeIntegration())
     _register(IflowIntegration())
     _register(JunieIntegration())
     _register(KilocodeIntegration())

src/specify_cli/integrations/forge/__init__.py

@@ -0,0 +1,151 @@
+"""Forge integration — forgecode.dev AI coding agent.
+
+Forge has several unique behaviors compared to standard markdown agents:
+- Uses `{{parameters}}` instead of `$ARGUMENTS` for argument passing
+- Strips `handoffs` frontmatter key (Forge-specific collaboration feature)
+- Injects `name` field into frontmatter when missing
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from ..base import IntegrationBase
+from ..manifest import IntegrationManifest
+
+
+class ForgeIntegration(IntegrationBase):
+    """Integration for Forge (forgecode.dev)."""
+
+    key = "forge"
+    config = {
+        "name": "Forge",
+        "folder": ".forge/",
+        "commands_subdir": "commands",
+        "install_url": "https://forgecode.dev/docs/",
+        "requires_cli": True,
+    }
+    registrar_config = {
+        "dir": ".forge/commands",
+        "format": "markdown",
+        "args": "{{parameters}}",
+        "extension": ".md",
+        "strip_frontmatter_keys": ["handoffs"],
+        "inject_name": True,
+    }
+    context_file = "AGENTS.md"
+
+    def setup(
+        self,
+        project_root: Path,
+        manifest: IntegrationManifest,
+        parsed_options: dict[str, Any] | None = None,
+        **opts: Any,
+    ) -> list[Path]:
+        """Install Forge commands with custom processing.
+
+        Processes command templates similarly to MarkdownIntegration but with
+        Forge-specific transformations:
+        1. Replaces {SCRIPT} and {ARGS} placeholders
+        2. Strips 'handoffs' frontmatter key
+        3. Injects 'name' field into frontmatter
+        4. Uses {{parameters}} instead of $ARGUMENTS
+        """
+        templates = self.list_command_templates()
+        if not templates:
+            return []
+
+        project_root_resolved = project_root.resolve()
+        if manifest.project_root != project_root_resolved:
+            raise ValueError(
+                f"manifest.project_root ({manifest.project_root}) does not match "
+                f"project_root ({project_root_resolved})"
+            )
+
+        dest = self.commands_dest(project_root).resolve()
+        try:
+            dest.relative_to(project_root_resolved)
+        except ValueError as exc:
+            raise ValueError(
+                f"Integration destination {dest} escapes "
+                f"project root {project_root_resolved}"
+            ) from exc
+        dest.mkdir(parents=True, exist_ok=True)
+
+        script_type = opts.get("script_type", "sh")
+        arg_placeholder = self.registrar_config.get("args", "{{parameters}}")
+        created: list[Path] = []
+
+        for src_file in templates:
+            raw = src_file.read_text(encoding="utf-8")
+            # Process template with Forge-specific argument placeholder
+            processed = self.process_template(raw, self.key, script_type, arg_placeholder)
+            
+            # Apply Forge-specific transformations
+            processed = self._apply_forge_transformations(processed, src_file.stem)
+            
+            dst_name = self.command_filename(src_file.stem)
+            dst_file = self.write_file_and_record(
+                processed, dest / dst_name, project_root, manifest
+            )
+            created.append(dst_file)
+
+        # Install integration-specific update-context scripts
+        created.extend(self.install_scripts(project_root, manifest))
+
+        return created
+
+    def _apply_forge_transformations(self, content: str, template_name: str) -> str:
+        """Apply Forge-specific transformations to processed content.
+
+        1. Strip 'handoffs' frontmatter key
+        2. Inject 'name' field if missing
+        """
+        import re
+
+        # Parse frontmatter
+        lines = content.split('\n')
+        if not lines or lines[0].strip() != '---':
+            return content
+
+        # Find end of frontmatter
+        frontmatter_end = -1
+        for i in range(1, len(lines)):
+            if lines[i].strip() == '---':
+                frontmatter_end = i
+                break
+
+        if frontmatter_end == -1:
+            return content
+
+        frontmatter_lines = lines[1:frontmatter_end]
+        body_lines = lines[frontmatter_end + 1:]
+
+        # 1. Strip 'handoffs' key
+        filtered_frontmatter = []
+        skip_until_outdent = False
+        for line in frontmatter_lines:
+            if skip_until_outdent:
+                # Skip indented lines under handoffs:
+                if line and (line[0] == ' ' or line[0] == '\t'):
+                    continue
+                else:
+                    skip_until_outdent = False
+            
+            if line.strip().startswith('handoffs:'):
+                skip_until_outdent = True
+                continue
+            
+            filtered_frontmatter.append(line)
+
+        # 2. Inject 'name' field if missing
+        has_name = any(line.strip().startswith('name:') for line in filtered_frontmatter)
+        if not has_name:
+            # Use the template name as the command name (e.g., "plan" -> "speckit.plan")
+            cmd_name = f"speckit.{template_name}"
+            filtered_frontmatter.insert(0, f'name: {cmd_name}')
+
+        # Reconstruct content
+        result = ['---'] + filtered_frontmatter + ['---'] + body_lines
+        return '\n'.join(result)

src/specify_cli/integrations/forge/scripts/update-context.ps1

@@ -0,0 +1,23 @@
+# update-context.ps1 — Forge integration: create/update AGENTS.md
+#
+# Thin wrapper that delegates to the shared update-agent-context script.
+# Activated in Stage 7 when the shared script uses integration.json dispatch.
+#
+# Until then, this delegates to the shared script as a subprocess.
+
+$ErrorActionPreference = 'Stop'
+
+# Derive repo root from script location (walks up to find .specify/)
+$scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Definition
+$repoRoot = try { git rev-parse --show-toplevel 2>$null } catch { $null }
+# If git did not return a repo root, or the git root does not contain .specify,
+# fall back to walking up from the script directory to find the initialized project root.
+if (-not $repoRoot -or -not (Test-Path (Join-Path $repoRoot '.specify'))) {
+    $repoRoot = $scriptDir
+    $fsRoot = [System.IO.Path]::GetPathRoot($repoRoot)
+    while ($repoRoot -and $repoRoot -ne $fsRoot -and -not (Test-Path (Join-Path $repoRoot '.specify'))) {
+        $repoRoot = Split-Path -Parent $repoRoot
+    }
+}
+
+& "$repoRoot/.specify/scripts/powershell/update-agent-context.ps1" -AgentType forge

src/specify_cli/integrations/forge/scripts/update-context.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+# update-context.sh — Forge integration: create/update AGENTS.md
+#
+# Thin wrapper that delegates to the shared update-agent-context script.
+# Activated in Stage 7 when the shared script uses integration.json dispatch.
+#
+# Until then, this delegates to the shared script as a subprocess.
+
+set -euo pipefail
+
+# Derive repo root from script location (walks up to find .specify/)
+_script_dir="$(cd "$(dirname "$0")" && pwd)"
+_root="$_script_dir"
+while [ "$_root" != "/" ] && [ ! -d "$_root/.specify" ]; do _root="$(dirname "$_root")"; done
+if [ -z "${REPO_ROOT:-}" ]; then
+  if [ -d "$_root/.specify" ]; then
+    REPO_ROOT="$_root"
+  else
+    git_root="$(git rev-parse --show-toplevel 2>/dev/null || true)"
+    if [ -n "$git_root" ] && [ -d "$git_root/.specify" ]; then
+      REPO_ROOT="$git_root"
+    else
+      REPO_ROOT="$_root"
+    fi
+  fi
+fi
+
+exec "$REPO_ROOT/.specify/scripts/bash/update-agent-context.sh" forge