@williambeto/ai-workflow 2.2.6 → 2.2.7

package/dist-assets/docs/compatibility/provider-usage.md

@@ -33,6 +33,14 @@ npx @williambeto/ai-workflow init --yes --gemini
 
 Review `GEMINI.md` and `.gemini/`. Gemini support remains experimental until real-runtime scenario evidence is recorded.
 
+## Antigravity
+
+```bash
+npx @williambeto/ai-workflow init --yes --antigravity
+```
+
+Review `ANTIGRAVITY.md` and `.agents/`. Antigravity support remains experimental until real-runtime scenario evidence is recorded.
+
 ## Multiple adapters
 
 Flags may be combined, but each generated runtime increases maintenance surface. Generate only the integrations the consumer project actually uses.

package/dist-assets/docs/compatibility/runtime-matrix.md

@@ -13,6 +13,7 @@
 | Codex | Supported with limitations | `.github/agents/`, `.agents/skills/`, `.codex/prompts/` | adapter/unit/structural checks and generated asset inspection | No claim of identical multi-agent execution; `.codex/` output is optional and only generated with `--codex` |
 | Claude Code | Supported with limitations | `CLAUDE.md`, `.claude/rules/` | adapter/unit/structural checks and generated asset inspection | Rule loading and tool permissions depend on Claude Code configuration |
 | Gemini CLI | Experimental | `GEMINI.md`, `.gemini/agents/`, `.gemini/skills/`, `.gemini/commands/` | adapter/unit/structural checks and generated asset inspection | Native discovery and command behavior require real Gemini CLI validation before `Supported` |
+| Antigravity | Supported | `ANTIGRAVITY.md`, `.agents/agents/`, `.agents/skills/`, `.agents/commands/` | unit tests, validation suite, and WSL/Desktop consumer validation | Agents are only listed under `/agents` when actively running (instantiated via `invoke_subagent`) |
 
 ## Claim policy
 

package/dist-assets/templates/.antigravityignore.template

@@ -0,0 +1,8 @@
+.ai-workflow/
+.ai-workflow-backups/
+node_modules/
+.git/
+EVIDENCE.json
+*.tgz
+*.zip
+*.tar

package/dist-assets/templates/ANTIGRAVITY.md.template

@@ -0,0 +1,20 @@
+# Antigravity Instructions — AI Workflow Kit
+
+Use AGENTS.md and the relevant contracts.
+
+```txt
+readonly → Inspect → Report → Recommendation
+quick → Branch recovery/check → Implement → Document if behavior or usage changed → Test/Validate → Evidence
+standard → Mini spec → Mini review → Mini plan → Scoped PR plan → Implement → Document → Test/Validate → Evidence
+full → Spec draft → Spec review → Technical plan → PR breakdown → Implementation → Documentation → Test/Validate → Evidence report
+```
+
+Use professional taxonomy: Primary Agents, Skill-backed Specialist Roles, Skills, Commands.
+
+
+## Documentation, UI, security, and delivery artifact gates
+
+- Explicit requirements, clean code, generated specs, and inline comments do not replace documentation.
+- For user-facing UI, rendered or visual evidence is required when the runtime can inspect it; raw/default browser UI is `FAIL_QUALITY_GATE`.
+- High/Critical security findings must be classified in evidence.
+- Implementation work must create delivery artifacts proportional to mode: quick uses compact evidence, standard uses compact workflow artifacts, and full uses the complete 01..07 set.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@williambeto/ai-workflow",
-  "version": "2.2.6",
+  "version": "2.2.7",
   "description": "AI Workflow Kit — OpenCode-first software delivery workflow with agents, commands, skills, validation, and evidence",
   "license": "MIT",
   "author": "José Willams",

package/src/adapters/index.js

@@ -1,3 +1,4 @@
 export { GeminiAdapter } from "./platforms/gemini.js";
 export { ClaudeAdapter } from "./platforms/claude.js";
 export { CodexAdapter } from "./platforms/codex.js";
+export { AntigravityAdapter } from "./platforms/antigravity.js";

package/src/adapters/platforms/antigravity.js

@@ -0,0 +1,382 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { COMPLETION_STATUS_TEXT } from "../../core/statuses.js";
+
+/**
+ * Maps OpenCode agent names to primary agent roles.
+ * @type {Record<string, string>}
+ */
+const PERSONA_MAPPING = {
+  "atlas": "Atlas",
+  "orion": "Orion",
+  "sage": "Sage",
+  "nexus": "Nexus",
+  "astra": "Astra",
+  "sage-validation": "Sage",
+  "orion-release": "Orion",
+  "orion-deploy": "Orion",
+  "nexus-discovery": "Nexus",
+  "phoenix": "Phoenix"
+};
+
+/**
+ * Antigravity Adapter - Transforms OpenCode .md to Antigravity Skill format and manages .agents/ integration.
+ */
+export class AntigravityAdapter {
+  constructor({ cwd }) {
+    this.cwd = cwd;
+  }
+
+  /**
+   * Transforms an OpenCode agent or specialized skill file to an Antigravity Skill.
+   * @param {string} filePath - Path to the source .md file.
+   * @returns {Promise<{content: string, name: string}>}
+   */
+  async transform(filePath) {
+    const content = await fs.readFile(filePath, "utf8");
+    const fileName = path.basename(filePath, ".md") === "SKILL" 
+      ? path.basename(path.dirname(filePath)) 
+      : path.basename(filePath, ".md");
+      
+    const persona = PERSONA_MAPPING[fileName.toLowerCase()] || "Astra";
+    
+    // Check if already has frontmatter
+    if (content.trim().startsWith("---")) {
+      return { content, name: fileName };
+    }
+
+    // Extract description from the first paragraph after the title
+    const descriptionMatch = content.match(/^# .*\n\n(.*)/m);
+    const description = descriptionMatch ? descriptionMatch[1].trim() : `Specialized agent for ${fileName}.`;
+
+    const skillContent = `---
+name: ${fileName}
+description: ${description}
+---
+# ${persona} Persona
+
+${content}
+
+##  Completion Contract (Mandatory)
+Every task completion MUST provide the following payload:
+1. **Status**: ${COMPLETION_STATUS_TEXT}
+2. **Scope reviewed**: Brief summary of what was analyzed.
+3. **Findings**: Evidence-based discoveries.
+4. **Files affected**: List of all concrete paths modified or created.
+5. **Validation/evidence**: Commands run and their results.
+6. **Risks/notes**: Any caveats or technical debt introduced.
+7. **Required manager action**: Clear next step for the orchestrator.
+8. **Can manager continue**: [yes/no]
+`;
+
+    return {
+      content: skillContent,
+      name: fileName
+    };
+  }
+
+  /**
+   * Deploys transformed skills and agents to their respective directories.
+   * Also orchestrates the .antigravity/ native integration.
+   */
+  async deploy(transformedItems, installRoot = ".ai-workflow") {
+    const agentsDir = path.join(this.cwd, installRoot, "opencode/agents");
+    const skillsDir = path.join(this.cwd, installRoot, "opencode/skills");
+    
+    await fs.mkdir(agentsDir, { recursive: true });
+    await fs.mkdir(skillsDir, { recursive: true });
+
+    for (const item of transformedItems) {
+      const isAgent = PERSONA_MAPPING[item.name.toLowerCase()];
+      const targetDir = isAgent ? agentsDir : path.join(skillsDir, item.name);
+      const fileName = isAgent ? `${item.name}.md` : "SKILL.md";
+      
+      const absoluteTargetDir = isAgent ? agentsDir : targetDir;
+      await fs.mkdir(absoluteTargetDir, { recursive: true });
+      await fs.writeFile(path.join(absoluteTargetDir, fileName), item.content);
+    }
+    
+    // Deploy native Antigravity extensions (.antigravity/)
+    await this.deployNativeExtensions(installRoot);
+
+    // Also deploy root ANTIGRAVITY.md if it doesn't exist
+    await this.deployInstructions();
+  }
+
+  /**
+   * Orchestrates the .agents/ directory with copies of .ai-workflow/ assets.
+   * Using hard copies instead of symlinks ensures native discovery across all platforms.
+   */
+  async deployNativeExtensions(installRoot = ".ai-workflow") {
+    const antigravityDir = path.join(this.cwd, ".agents");
+    const antigravityAgents = path.join(antigravityDir, "agents");
+    const antigravitySkills = path.join(antigravityDir, "skills");
+    const antigravityCommands = path.join(antigravityDir, "commands");
+
+    await fs.mkdir(antigravityAgents, { recursive: true });
+    await fs.mkdir(antigravitySkills, { recursive: true });
+    await fs.mkdir(antigravityCommands, { recursive: true });
+
+    const getUrls = (targetPath) => {
+      const linuxUrl = pathToFileURL(targetPath).href;
+      const urls = [linuxUrl];
+      
+      if (process.platform === "linux" && process.env.WSL_DISTRO_NAME) {
+        const distro = process.env.WSL_DISTRO_NAME;
+        const normalizedPath = targetPath.replaceAll("\\", "/");
+        urls.push(`file://wsl.localhost/${distro}${normalizedPath}`);
+        urls.push(`file:///wsl.localhost/${distro}${normalizedPath}`);
+      }
+      
+      return urls.join("\n");
+    };
+
+    const toolNames = [
+      "send_message",
+      "find_by_name",
+      "grep_search",
+      "view_file",
+      "list_dir",
+      "read_url_content",
+      "search_web",
+      "schedule",
+      "multi_replace_file_content",
+      "replace_file_content",
+      "write_to_file",
+      "run_command",
+      "manage_task",
+      "define_subagent",
+      "invoke_subagent",
+      "manage_subagents",
+      "call_mcp_tool"
+    ];
+
+    const systemPromptConfig = {
+      "includeSections": [
+        "user_information",
+        "mcp_servers",
+        "skills",
+        "subagent_reminder",
+        "messaging",
+        "artifacts",
+        "user_rules"
+      ]
+    };
+
+    // 1. Deploy Primary Agents to .agents/agents/{agent_name}/
+    const sourceAgentsDir = path.join(this.cwd, installRoot, "opencode/agents");
+    const agentFiles = await fs.readdir(sourceAgentsDir).catch(() => []);
+
+    const AGENTS_INFO = {
+      "atlas": { name: "Atlas", description: "Router and workflow coordinator for AI Workflow Kit" },
+      "nexus": { name: "Nexus", description: "Discovery, requirement, scope, and specification owner" },
+      "orion": { name: "Orion", description: "Planning, PR sequencing, release, and deployment strategy owner" },
+      "astra": { name: "Astra", description: "Implementation owner for incremental, scoped changes" },
+      "sage": { name: "Sage", description: "Audit, validation, evidence, and quality gate owner" },
+      "phoenix": { name: "Phoenix", description: "Remediation and regression recovery owner" }
+    };
+
+    for (const file of agentFiles) {
+      if (!file.endsWith(".md")) continue;
+      const lowercaseName = path.basename(file, ".md").toLowerCase();
+      const info = AGENTS_INFO[lowercaseName];
+      if (!info) continue;
+
+      const agentFolder = path.join(antigravityAgents, lowercaseName);
+      await fs.mkdir(agentFolder, { recursive: true });
+
+      // Copy Markdown file to the agent's folder
+      const content = await fs.readFile(path.join(sourceAgentsDir, file), "utf8");
+      const mdTarget = path.join(agentFolder, `${lowercaseName}.md`);
+      await fs.writeFile(mdTarget, content);
+
+      // Generate agent.json
+      const agentJson = {
+        name: lowercaseName,
+        description: info.description,
+        hidden: false,
+        config: {
+          customAgent: {
+            systemPromptSections: [
+              {
+                title: "Agent System Instructions",
+                content: `You are ${info.name}, the ${lowercaseName === "astra" ? "implementation" : lowercaseName} owner.\n\nFollow the contract instructions in:\n${getUrls(mdTarget)}`
+              }
+            ],
+            toolNames,
+            systemPromptConfig
+          }
+        }
+      };
+      await fs.writeFile(path.join(agentFolder, "agent.json"), JSON.stringify(agentJson, null, 2));
+    }
+
+    // 2. Deploy Subagents to .agents/agents/{subagent_name}/
+    const SUBAGENTS_INFO = {
+      "Architecture-Specialist": { description: "Select the simplest architecture that safely satisfies current requirements", skill: "architecture" },
+      "Backend-Engineer": { description: "Support safe PHP/Node/Python backend changes for APIs and persistence", skill: "backend-development" },
+      "Deployment-Specialist": { description: "Plan, review, or validate deployment, release, and production-readiness", skill: "deployment" },
+      "Design-Specialist": { description: "Apply practical design principles to keep solutions simple and maintainable", skill: "design-principles" },
+      "Docs-Engineer": { description: "Write or improve project documentation, READMEs, guides, and prompts", skill: "documentation" },
+      "Frontend-Engineer": { description: "Implement or review frontend changes involving UI, state, routing, and accessibility", skill: "frontend-development" },
+      "Full-Stack-Engineer": { description: "Coordinate frontend and backend changes as one coherent, testable increment", skill: "full-stack-development" },
+      "Token-Economist": { description: "Reduce context size while preserving information required for safe execution", skill: "optimize-tokens" },
+      "PR-Manager": { description: "Plan, implement, review, or validate small pull requests while preserving scope", skill: "pr-workflow" },
+      "Discovery-Analyst": { description: "Clarify ambiguous requests into actionable problem statements and success outcomes", skill: "product-discovery" },
+      "Product-Planner": { description: "Turn clarified needs into scoped requirements with acceptance-ready outcomes", skill: "product-planning" },
+      "Memory-Guardian": { description: "Manage discoverable project memory for durable decisions and recurring corrections", skill: "project-memory" },
+      "Prompt-Engineer": { description: "Expert in creating and refining prompts for AI agents and workflows", skill: "prompt-engineer" },
+      "QA-Engineer": { description: "Design, review, or improve tests, acceptance criteria, and validation evidence", skill: "qa-workflow" },
+      "Refactoring-Specialist": { description: "Improve code/document structure safely while preserving behavior", skill: "refactoring" },
+      "Release-Specialist": { description: "Prepare release readiness decisions with explicit gates and evidence", skill: "release-workflow" },
+      "SDD-Specialist": { description: "Convert approved requirements into explicit, testable specification artifacts", skill: "spec-driven-development" },
+      "Technical-Leader": { description: "Make technical decisions, review architecture, and identify trade-offs", skill: "technical-leadership" },
+      "UI-UX-Engineer": { description: "Improve usability and interface clarity without introducing unnecessary complexity", skill: "ui-ux-design" }
+    };
+
+    for (const [name, subInfo] of Object.entries(SUBAGENTS_INFO)) {
+      const lowercaseSubagentName = name.toLowerCase();
+      const subagentFolder = path.join(antigravityAgents, lowercaseSubagentName);
+      await fs.mkdir(subagentFolder, { recursive: true });
+
+      const skillPath = path.join(antigravitySkills, subInfo.skill, "SKILL.md");
+
+      const subagentJson = {
+        name: lowercaseSubagentName,
+        description: subInfo.description,
+        hidden: false,
+        config: {
+          customAgent: {
+            systemPromptSections: [
+              {
+                title: "Agent System Instructions",
+                content: `You are ${name}.\n\nFollow the contract instructions in:\n${getUrls(skillPath)}`
+              }
+            ],
+            toolNames,
+            systemPromptConfig
+          }
+        }
+      };
+      await fs.writeFile(path.join(subagentFolder, "agent.json"), JSON.stringify(subagentJson, null, 2));
+    }
+
+    // 3. Copy Skills
+    const sourceSkillsDir = path.join(this.cwd, installRoot, "opencode/skills");
+    const skillFolders = await fs.readdir(sourceSkillsDir).catch(() => []);
+    for (const folder of skillFolders) {
+      const skillSource = path.join(sourceSkillsDir, folder, "SKILL.md");
+      if (await this.exists(skillSource)) {
+        await fs.mkdir(path.join(antigravitySkills, folder), { recursive: true });
+        const content = await fs.readFile(skillSource, "utf8");
+        await fs.writeFile(path.join(antigravitySkills, folder, "SKILL.md"), content);
+      }
+    }
+
+    // 4. Copy Commands (from dist-assets/commands)
+    const sourceCommandsDir = path.join(this.cwd, installRoot, "opencode/commands");
+    if (await this.exists(sourceCommandsDir)) {
+      const commandFiles = await fs.readdir(sourceCommandsDir).catch(() => []);
+      for (const file of commandFiles) {
+        if (!file.endsWith(".md") && !file.endsWith(".toml")) continue;
+        const content = await fs.readFile(path.join(sourceCommandsDir, file), "utf8");
+        await fs.writeFile(path.join(antigravityCommands, file), content);
+      }
+    }
+
+    // 5. Copy governance policy into .agents/docs/policies/ so the relative
+    //    link ../../docs/policies/SKILLS_COMMON_GOVERNANCE.md in each
+    //    .agents/skills/{skill}/SKILL.md resolves correctly.
+    const sourcePoliciesDir = path.join(this.cwd, installRoot, "opencode", "docs", "policies");
+    const antigravityPolicies = path.join(antigravityDir, "docs", "policies");
+    if (await this.exists(sourcePoliciesDir)) {
+      await fs.mkdir(antigravityPolicies, { recursive: true });
+      const policyFiles = await fs.readdir(sourcePoliciesDir).catch(() => []);
+      for (const file of policyFiles) {
+        if (!file.endsWith(".md")) continue;
+        const content = await fs.readFile(path.join(sourcePoliciesDir, file), "utf8");
+        await fs.writeFile(path.join(antigravityPolicies, file), content);
+      }
+    }
+
+    // 6. Inject project settings.json
+    const settingsPath = path.join(antigravityDir, "settings.json");
+    if (!(await this.exists(settingsPath))) {
+      const settings = {
+        model: { name: "auto" },
+        ui: { theme: "Ayu" }
+      };
+      await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+    }
+  }
+
+  async exists(p) {
+    try {
+      await fs.access(p);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Deploys the main ANTIGRAVITY.md and .antigravityignore instructions to the project root.
+   */
+  async deployInstructions() {
+    const targetPath = path.join(this.cwd, "ANTIGRAVITY.md");
+    const ignorePath = path.join(this.cwd, ".antigravityignore");
+    
+    // Deploy ANTIGRAVITY.md if it doesn't exist
+    try {
+      await fs.access(targetPath);
+    } catch {
+      const instructions = `# AI Workflow Kit - Engineering Governance
+
+## Mandate: Atlas Authority Protocol
+All architectural changes must align with the specifications issued by the **Specification Authority** (./specs).
+
+## Ternary Architecture
+- **Root:** Orchestration and config.
+- **.ai-workflow/:** Implementation (The Muscle).
+- **./specs:** Specifications (The Brain).
+
+## Branch Gates
+- **main Branch:** READ-ONLY.
+- **Validation:** Merges require successful observed validation; full/release workflows may persist EVIDENCE.json.
+
+## Primary Agents
+- **Atlas (Orchestrator)**
+- **Orion (Strategist)**
+- **Sage (Auditor)**
+- **Nexus (Spec Architect)**
+- **Astra (Developer)**
+- **Phoenix (Healer)**
+
+## Operational Preferences
+- Use \`token-economy\` and \`minimal-context\` skills.
+- **Native Discovery**: This project uses workspace-specific extensions in \`.agents/\`.
+- **Workflow Entry**: Use \`/atlas\` to begin any task.
+`;
+      await fs.writeFile(targetPath, instructions);
+    }
+
+    // Deploy .antigravityignore if it doesn't exist
+    try {
+      await fs.access(ignorePath);
+    } catch {
+      const ignoreContent = `.ai-workflow/
+.ai-workflow-backups/
+node_modules/
+.git/
+EVIDENCE.json
+*.tgz
+*.zip
+*.tar
+.agents/tmp/
+.agents/history/
+`;
+      await fs.writeFile(ignorePath, ignoreContent);
+    }
+  }
+}

package/src/adapters/platforms/codex.js

@@ -87,6 +87,19 @@ Every task completion MUST provide the following payload:
       const content = await fs.readFile(path.join(sourceCommandsDir, file), "utf8");
       await fs.writeFile(path.join(codexPromptsDir, targetFileName), content);
     }
+
+    // 4. Copy governance policy into .agents/docs/policies/ so the relative
+    //    link ../../docs/policies/SKILLS_COMMON_GOVERNANCE.md in each
+    //    .agents/skills/{skill}/SKILL.md resolves correctly.
+    const codexPoliciesDir = path.join(this.cwd, ".agents", "docs", "policies");
+    await fs.mkdir(codexPoliciesDir, { recursive: true });
+    const sourcePoliciesDir = path.join(this.cwd, installRoot, "opencode", "docs", "policies");
+    const policyFiles = await fs.readdir(sourcePoliciesDir).catch(() => []);
+    for (const file of policyFiles) {
+      if (!file.endsWith(".md")) continue;
+      const policyContent = await fs.readFile(path.join(sourcePoliciesDir, file), "utf8");
+      await fs.writeFile(path.join(codexPoliciesDir, file), policyContent);
+    }
   }
 
   async exists(p) {

package/src/adapters/platforms/gemini.js

@@ -150,7 +150,20 @@ Every task completion MUST provide the following payload:
       }
     }
 
-    // 4. Inject project settings.json
+    // 4. Copy governance policy into .gemini/docs/policies/ so the relative
+    //    link ../../docs/policies/SKILLS_COMMON_GOVERNANCE.md in each
+    //    .gemini/skills/{skill}/SKILL.md resolves correctly.
+    const geminiPoliciesDir = path.join(geminiDir, "docs", "policies");
+    await fs.mkdir(geminiPoliciesDir, { recursive: true });
+    const sourcePoliciesDir = path.join(this.cwd, installRoot, "opencode", "docs", "policies");
+    const policyFiles = await fs.readdir(sourcePoliciesDir).catch(() => []);
+    for (const file of policyFiles) {
+      if (!file.endsWith(".md")) continue;
+      const content = await fs.readFile(path.join(sourcePoliciesDir, file), "utf8");
+      await fs.writeFile(path.join(geminiPoliciesDir, file), content);
+    }
+
+    // 5. Inject project settings.json
     const settingsPath = path.join(geminiDir, "settings.json");
     if (!(await this.exists(settingsPath))) {
       const settings = {

package/src/cli.js

@@ -11,7 +11,7 @@ function printHelp() {
 Usage:
   ai-workflow execute "<request>" [--task=<slug>] [--request="<request>"]
   ai-workflow run --spec-path=<path>
-  ai-workflow init [--yes] [--force] [--dry-run] [--no-install] [--no-overwrite] [--gemini] [--claude] [--codex] [--profile=<profile>]
+  ai-workflow init [--yes] [--force] [--dry-run] [--no-install] [--no-overwrite] [--gemini] [--claude] [--codex] [--antigravity] [--profile=<profile>]
   ai-workflow collect-evidence [--task=<slug>] [--mode=<quick|standard|full>] [--dry-run]
   ai-workflow doctor
 
@@ -46,6 +46,7 @@ function parseFlags(args) {
     gemini: args.includes("--gemini"),
     claude: args.includes("--claude"),
     codex: args.includes("--codex"),
+    antigravity: args.includes("--antigravity"),
     "dev-mode": args.includes("--dev-mode"),
     specPath: specPathArg ? specPathArg.replace("--spec-path=", "") : undefined,
     profile: profileVal || undefined,

package/src/commands/init.js

@@ -6,7 +6,7 @@ import { exists, writeFileSafe, readJson } from "../core/filesystem.js";
 import { createManagedBackup, createManagedPathBackup } from "../core/backup.js";
 import { mergeOpencodeConfig } from "../core/opencode-merge.js";
 import { buildSymlinkEntries, isSymlinkTo, setupInternalSymlinks } from "../core/symlink-layout.js";
-import { GeminiAdapter, ClaudeAdapter, CodexAdapter } from "../adapters/index.js";
+import { GeminiAdapter, ClaudeAdapter, CodexAdapter, AntigravityAdapter } from "../adapters/index.js";
 
 function summarize(actions) {
   const createCount = actions.filter((a) => a.type === "create").length;
@@ -100,7 +100,7 @@ async function injectScripts(cwd) {
 }
 
 export async function runInit({
- cwd, yes, force, dryRun, noInstall, noOverwrite, gemini, claude, codex, "dev-mode": devMode, profile }) {
+ cwd, yes, force, dryRun, noInstall, noOverwrite, gemini, claude, codex, antigravity, "dev-mode": devMode, profile }) {
   // Self-execution guard
   if (!devMode) {
     try {
@@ -131,6 +131,7 @@ export async function runInit({
   if (gemini) platforms.push("gemini");
   if (claude) platforms.push("claude");
   if (codex) platforms.push("codex");
+  if (antigravity) platforms.push("antigravity");
 
   console.log(`ai-workflow: initializing in ${cwd}`);
   console.log(`Profile: ${selectedProfile}`);
@@ -260,6 +261,9 @@ export async function runInit({
   if (claude) {
     generatedIgnoreEntries.push(".claude/");
   }
+  if (antigravity) {
+    generatedIgnoreEntries.push(".agents/");
+  }
 
   const gitignoreResult = await upsertGitignoreBlock(cwd, generatedIgnoreEntries);
   const scriptInjected = await injectScripts(cwd);
@@ -303,6 +307,25 @@ export async function runInit({
       await adapter.deploy(installRoot);
       console.log("- codex: deployed AI Workflow Kit agents to .agents/, .codex/, and .github/ (native discovery enabled)");
     }
+
+    if (antigravity) {
+      const adapter = new AntigravityAdapter({ cwd });
+      
+      // Collect specialized skills from the new opencode/skills path
+      const skillFolders = await fs.readdir(skillsDir).catch(() => []);
+      const skillFiles = [];
+      for (const folder of skillFolders) {
+        const skillPath = path.join(skillsDir, folder, "SKILL.md");
+        if (await exists(skillPath)) {
+          skillFiles.push(skillPath);
+        }
+      }
+
+      const allFiles = [...agentFiles, ...skillFiles];
+      const transformed = await Promise.all(allFiles.map((f) => adapter.transform(f)));
+      await adapter.deploy(transformed, installRoot);
+      console.log(`- antigravity: deployed AI Workflow Kit agents to .agents/ (native discovery enabled)`);
+    }
   }
 
   console.log("Installation complete.");

package/src/core/gates/merge-gate.js

@@ -0,0 +1,74 @@
+import { execSync } from "node:child_process";
+
+/**
+ * MergeGate verifies that commit history on integration branches respects
+ * the non-fast-forward (--no-ff) merge strategy, preserving feature branch
+ * topology instead of flattening/fast-forwarding.
+ */
+export class MergeGate {
+  constructor({ cwd = process.cwd() } = {}) {
+    this.cwd = cwd;
+  }
+
+  runGit(command) {
+    return execSync(command, {
+      cwd: this.cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
+  }
+
+  /**
+   * Checks the commit history of the repository/branch.
+   * @param {string} branchName The branch to check.
+   * @returns {{ status: "PASS" | "FAIL_QUALITY_GATE" | "ERROR", reason?: string }}
+   */
+  check(branchName) {
+    try {
+      // Get the last 50 commits with parent hashes and subjects
+      const logOutput = this.runGit('git log -n 50 --format="%H|%P|%s"');
+      const lines = logOutput.split("\n").filter(Boolean);
+
+      const commits = lines.map((line) => {
+        const parts = line.split("|");
+        const hash = parts[0] || "";
+        const parentsStr = parts[1] || "";
+        const parents = parentsStr.split(" ").filter(Boolean);
+        const subject = parts[2] || "";
+        return { hash, parents, subject };
+      });
+
+      // 1. Enforce that any commit containing merge-like patterns in its subject must have at least 2 parents
+      for (const commit of commits) {
+        const isMergeSubject = /merge\b/i.test(commit.subject) || /pull request/i.test(commit.subject);
+        if (isMergeSubject && commit.parents.length < 2) {
+          return {
+            status: "FAIL_QUALITY_GATE",
+            reason: `Linear or fast-forward merge detected for commit '${commit.hash.slice(0, 7)}' ("${commit.subject}"). Merges into integration branches must use the non-fast-forward (--no-ff) strategy to preserve topology.`
+          };
+        }
+      }
+
+      // 2. If the current branch is an integration branch, ensure it contains at least one merge commit (2+ parents)
+      // to establish non-linear history, unless the repository has very few commits (e.g. initial setup).
+      const isIntegrationBranch = ["main", "master"].includes(branchName) || String(branchName).startsWith("release");
+      if (isIntegrationBranch && commits.length > 5) {
+        const hasMergeCommit = commits.some((c) => c.parents.length >= 2);
+        if (!hasMergeCommit) {
+          return {
+            status: "FAIL_QUALITY_GATE",
+            reason: `Integration branch '${branchName}' has a purely linear commit history. Integrated branches must use non-fast-forward (--no-ff) merges to preserve feature branches.`
+          };
+        }
+      }
+
+      return { status: "PASS" };
+    } catch (error) {
+      // If we are not inside a git repo or git is not available, we fail-closed or report error
+      return {
+        status: "ERROR",
+        reason: `Failed to check merge integrity: ${error.message}`
+      };
+    }
+  }
+}

package/src/core/templates.js

@@ -62,6 +62,14 @@ function buildRuntimeFiles({ includeFormalEvidence = false } = {}) {
     }
   }
 
+  // Copy governance policy into opencode/docs/policies/ so the relative link
+  // ../../docs/policies/SKILLS_COMMON_GOVERNANCE.md resolves correctly from
+  // opencode/skills/{skill}/SKILL.md for OpenCode and all platform adapters.
+  const opencodeGovernancePolicy = readPackageFile("dist-assets/docs/policies/SKILLS_COMMON_GOVERNANCE.md");
+  if (opencodeGovernancePolicy !== null) {
+    files["opencode/docs/policies/SKILLS_COMMON_GOVERNANCE.md"] = opencodeGovernancePolicy;
+  }
+
   const commandFiles = discoverPackageFiles("dist-assets/commands");
   for (const [relPath, content] of Object.entries(commandFiles)) {
     const targetPath = relPath.replace(/^dist-assets\//, "opencode/");

package/src/core/validation/evidence-collector.js

@@ -42,9 +42,13 @@ export class EvidenceCollector {
     if (task.presetStatus) {
       return { name: task.name, command: task.command, kind, status: task.presetStatus, exitCode: null, summary: task.summary, output: "" };
     }
+    const isWin32 = process.platform === "win32";
+    const isUncPath = typeof this.cwd === "string" && (this.cwd.startsWith("\\\\") || this.cwd.startsWith("//"));
+    const shellOption = isWin32 && isUncPath ? "powershell.exe" : true;
+
     const result = spawnSync(task.command, {
       cwd: this.cwd,
-      shell: true,
+      shell: shellOption,
       encoding: "utf8",
       timeout: this.timeout
     });

package/src/core/validation/quality-guard.js

@@ -1,6 +1,7 @@
 import { execSync } from "node:child_process";
 import fs from "node:fs/promises";
 import path from "node:path";
+import { MergeGate } from "../gates/merge-gate.js";
 
 const PROTECTED_BRANCHES = new Set(["main", "master"]);
 
@@ -146,6 +147,13 @@ export class QualityGuard {
     if (implementation && PROTECTED_BRANCHES.has(branch)) {
       return { status: "FAIL_QUALITY_GATE", branch, reason: `Implementation changes are present on protected branch '${branch}'.` };
     }
+    if (this.mode === "full") {
+      const mergeGate = new MergeGate({ cwd: this.cwd });
+      const mergeResult = mergeGate.check(branch);
+      if (mergeResult.status === "FAIL_QUALITY_GATE") {
+        return { status: "FAIL_QUALITY_GATE", branch, reason: mergeResult.reason };
+      }
+    }
     return { status: "PASS", branch };
   }