ganbatte-os 0.2.33 → 0.2.35

package/.gos/scripts/integrations/check-plan.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+/**
+ * check-plan.js — barreira deterministica de criacao de plano.
+ *
+ * Roda como ULTIMA acao obrigatoria do *plan (apos plan-blueprint +
+ * plan-to-tasks). Valida que o plano e usavel pelo *execute-plan e
+ * *validate-plan. Falha = *plan nao terminou — usuario ve erro, nao
+ * "plano criado" ilusorio.
+ *
+ * Uso:
+ *   node check-plan.js <plan-dir>
+ *
+ * Verificacoes:
+ * 1. plan.md existe e tem frontmatter YAML.
+ * 2. context.md existe.
+ * 3. tasks/ existe e contem >= 1 T-NN*.md.
+ * 4. Cada T-NN*.md: head -1 == "---" E frontmatter contem `status: pendente`
+ *    E `id:`, `plan_id:`, `seq:`, `title:`.
+ * 5. Nenhum T-NN*.md tem secao `## Status` no body (formato bugado legado).
+ *
+ * Exit code:
+ *   0 = plano valido, usavel pelo pipeline
+ *   1 = falha — mensagem aponta exatamente o que esta errado
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const planDir = process.argv[2];
+
+if (!planDir) {
+  console.error('uso: check-plan.js <plan-dir>');
+  process.exit(1);
+}
+
+if (!fs.existsSync(planDir)) {
+  console.error(`[check-plan] FALHA: plan-dir nao existe: ${planDir}`);
+  process.exit(1);
+}
+
+const errors = [];
+const warnings = [];
+
+const planFile = path.join(planDir, 'plan.md');
+const contextFile = path.join(planDir, 'context.md');
+const tasksDir = path.join(planDir, 'tasks');
+
+if (!fs.existsSync(planFile)) {
+  errors.push(`plan.md ausente em ${planDir}`);
+} else {
+  const plan = fs.readFileSync(planFile, 'utf8');
+  if (!plan.startsWith('---\n')) {
+    errors.push(`plan.md sem frontmatter YAML (head -1 != "---")`);
+  }
+}
+
+if (!fs.existsSync(contextFile)) {
+  warnings.push(`context.md ausente — recomendado, nao bloqueia`);
+}
+
+if (!fs.existsSync(tasksDir)) {
+  errors.push(`tasks/ ausente em ${planDir} — *plan deve invocar plan-to-tasks`);
+} else {
+  const taskFiles = fs.readdirSync(tasksDir)
+    .filter((f) => /^T-\d+.*\.md$/.test(f))
+    .map((f) => path.join(tasksDir, f));
+
+  if (taskFiles.length === 0) {
+    errors.push(`tasks/ vazio — nenhum T-NN*.md encontrado`);
+  }
+
+  for (const file of taskFiles) {
+    const rel = path.relative(planDir, file);
+    const raw = fs.readFileSync(file, 'utf8');
+
+    if (!raw.startsWith('---\n')) {
+      errors.push(`${rel}: sem frontmatter YAML (head -1 != "---")`);
+      continue;
+    }
+
+    const fmEnd = raw.indexOf('\n---', 4);
+    if (fmEnd === -1) {
+      errors.push(`${rel}: frontmatter aberto sem fechar ("---" final ausente)`);
+      continue;
+    }
+    const frontmatter = raw.slice(4, fmEnd);
+    const body = raw.slice(fmEnd + 4);
+
+    const required = ['id', 'plan_id', 'seq', 'title', 'status'];
+    for (const key of required) {
+      if (!new RegExp(`^${key}:\\s*\\S`, 'm').test(frontmatter)) {
+        errors.push(`${rel}: frontmatter sem campo \`${key}:\``);
+      }
+    }
+
+    if (!/^status:\s*pendente\s*$/m.test(frontmatter)) {
+      errors.push(`${rel}: frontmatter status: deve ser exatamente "pendente" no plano recem-criado`);
+    }
+
+    if (/^## Status\s*$/m.test(body)) {
+      errors.push(`${rel}: contem secao "## Status" no body (formato legado bugado) — rodar migrate-task-status.js`);
+    }
+  }
+}
+
+if (warnings.length) {
+  for (const w of warnings) console.error(`[check-plan] aviso: ${w}`);
+}
+
+if (errors.length) {
+  console.error(`\n[check-plan] FALHA — plano NAO usavel pelo *execute-plan:\n`);
+  for (const e of errors) console.error(`  - ${e}`);
+  console.error(`\nproximo passo: regerar tasks via plan-to-tasks OU rodar migrate-task-status.js ${planDir}`);
+  process.exit(1);
+}
+
+const taskCount = fs.readdirSync(tasksDir)
+  .filter((f) => /^T-\d+.*\.md$/.test(f)).length;
+console.log(`[check-plan] OK — ${planDir}: plan.md + context.md + ${taskCount} tasks (todas com frontmatter status: pendente).`);
+process.exit(0);

package/.gos/scripts/integrations/migrate-task-status.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+/**
+ * migrate-task-status.js
+ *
+ * Migra task files do formato bugado (`## Status` no body, sem frontmatter)
+ * para o formato canonico (frontmatter YAML com `status:`).
+ *
+ * Origem do bug: plan-to-tasks/SKILL.md tinha template inline obsoleto sem
+ * `status:`. Tasks geradas ficavam travadas em `pendente` mesmo apos
+ * *execute-plan rodar codigo, porque progress-tracker procura no frontmatter
+ * e nao acha. Corrigido em commit subsequente; este script reabilita planos
+ * preexistentes.
+ *
+ * Uso:
+ *   node migrate-task-status.js <plan-dir>
+ *   node migrate-task-status.js <plan-dir> --infer-from-diff
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+
+const args = process.argv.slice(2);
+const planDir = args[0];
+const inferFromDiff = args.includes('--infer-from-diff');
+
+if (!planDir || !fs.existsSync(planDir)) {
+  console.error('uso: migrate-task-status.js <plan-dir> [--infer-from-diff]');
+  process.exit(1);
+}
+
+const tasksDir = path.join(planDir, 'tasks');
+if (!fs.existsSync(tasksDir)) {
+  console.error(`tasks dir nao encontrado: ${tasksDir}`);
+  process.exit(1);
+}
+
+const planFile = path.join(planDir, 'plan.md');
+const planSlug = path.basename(planDir);
+const planId = planSlug.split('-').slice(0, 2).join('-');
+
+function gitLog(args) {
+  try {
+    return execFileSync('git', args, { encoding: 'utf8' }).trim();
+  } catch {
+    return '';
+  }
+}
+
+const taskFiles = fs.readdirSync(tasksDir)
+  .filter((f) => /^T-\d+.*\.md$/.test(f))
+  .map((f) => path.join(tasksDir, f));
+
+let migrated = 0;
+let skipped = 0;
+let failed = 0;
+
+for (const file of taskFiles) {
+  const raw = fs.readFileSync(file, 'utf8');
+
+  if (raw.startsWith('---\n')) {
+    skipped++;
+    continue;
+  }
+
+  const titleMatch = raw.match(/^# (T-\d+(?:-\d+)?)[ —-]+(.+?)$/m);
+  const statusMatch = raw.match(/^## Status\s*\n+`?(\w[\w-]*)`?/m);
+
+  if (!titleMatch) {
+    console.error(`falha: ${file} — sem heading T-NN`);
+    failed++;
+    continue;
+  }
+
+  const taskId = titleMatch[1];
+  const title = titleMatch[2].trim();
+  const seqRaw = (taskId.match(/T-(\d+)(?:-(\d+))?/) || [])[2] || taskId.split('-')[1];
+  const bodyStatus = statusMatch ? statusMatch[1] : 'pendente';
+
+  let finalStatus = bodyStatus;
+  if (inferFromDiff && bodyStatus === 'pendente') {
+    const addCommit = gitLog(['log', '--diff-filter=A', '--format=%H', '--', planFile]);
+    const sinceCommit = addCommit ? addCommit.split('\n').pop() : '';
+    if (sinceCommit) {
+      const diff = gitLog(['log', `${sinceCommit}..HEAD`, '--name-only', '--pretty=format:']);
+      if (diff) finalStatus = 'validacao';
+    }
+  }
+
+  const bodyWithoutStatus = raw
+    .replace(/^## Status\s*\n+`?\w[\w-]*`?\s*\n+/m, '')
+    .replace(/^# T-\d+.*?\n+/m, '');
+
+  const frontmatter = `---
+id: ${taskId}
+plan_id: ${planId}
+seq: ${parseInt(seqRaw, 10)}
+title: ${title}
+area: frontend
+labels: [agent:dev]
+priority: P1
+estimate: "4h"
+status: ${finalStatus}
+valida_em: ""
+depends_on_backend: []
+interaction_target: []
+override_target: []
+assignees: []
+links: []
+---
+
+# ${taskId} — ${title}
+
+`;
+
+  fs.writeFileSync(file, frontmatter + bodyWithoutStatus);
+  migrated++;
+  console.log(`migrado: ${path.basename(file)} → status=${finalStatus}`);
+}
+
+console.log(`\n[migrate-task-status] ${migrated} migrados | ${skipped} ja-validos | ${failed} falhas`);
+process.exit(failed > 0 ? 1 : 0);

package/.gos/scripts/integrations/setup-ide-adapters.js

@@ -22,15 +22,53 @@ function relativeTarget(fromFile, targetFile) {
   return path.relative(path.dirname(fromFile), targetFile).replace(/\\/g, '/');
 }
 
+function agentSlug(id) {
+  return id.startsWith('gos-') ? id : `gos-${id}`;
+}
+
+function cleanupStaleAdapters() {
+  // Remove arquivos .md soltos no root de skills/ (formato legado) em todas as IDEs.
+  // Codex/Qwen/Gemini/Opencode/Antigravity esperam <slug>/SKILL.md (diretorio), nao .md solto.
+  // .agent e o diretorio canonico do Antigravity (workspace scope: .agent/skills/, .agent/workflows/).
+  const allIdes = ['.codex', '.qwen', '.gemini', '.opencode', '.agent'];
+  for (const ide of allIdes) {
+    const skillsDir = path.join(root, ide, 'skills');
+    if (fs.existsSync(skillsDir)) {
+      for (const entry of fs.readdirSync(skillsDir)) {
+        const full = path.join(skillsDir, entry);
+        if (fs.statSync(full).isFile() && entry.endsWith('.md')) {
+          fs.unlinkSync(full);
+        }
+      }
+    }
+    const agentsDir = path.join(root, ide, 'agents');
+    if (fs.existsSync(agentsDir)) {
+      for (const entry of fs.readdirSync(agentsDir)) {
+        if (/^gos-gos-/.test(entry)) {
+          fs.unlinkSync(path.join(agentsDir, entry));
+        }
+      }
+    }
+  }
+
+  // Legado: .antigravity/ era o diretorio errado (Antigravity nunca leu isso — usa .agent/).
+  // Remove silenciosamente para evitar drift entre IDEs.
+  const legacyAntigravity = path.join(root, '.antigravity');
+  if (fs.existsSync(legacyAntigravity)) {
+    fs.rmSync(legacyAntigravity, { recursive: true, force: true });
+  }
+}
+
 function agentWrapper(agentId, target) {
   return `# ${agentId}\n\nFonte canonica: \`${target}\`\n\nLeia e siga o perfil em \`${target}\`.\nEste arquivo existe apenas como adapter fino para a IDE.`;
 }
 
 function skillWrapper(slug, target, description) {
-  const body = `# gos-${slug}\n\nFonte canonica: \`${target}\`\n\nLeia e siga a skill em \`${target}\`.\nEste arquivo existe apenas como adapter fino para a IDE.`;
+  const fullSlug = slug.startsWith('gos-') ? slug : `gos-${slug}`;
+  const body = `# ${fullSlug}\n\nFonte canonica: \`${target}\`\n\nLeia e siga a skill em \`${target}\`.\nEste arquivo existe apenas como adapter fino para a IDE.`;
   if (!description) return body;
   const desc = String(description).replace(/"/g, '\\"').replace(/\n/g, ' ').slice(0, 200);
-  return `---\nname: "gos-${slug}"\ndescription: "${desc}"\n---\n\n${body}`;
+  return `---\nname: "${fullSlug}"\ndescription: "${desc}"\n---\n\n${body}`;
 }
 
 function qwenCommandWrapper(name, description, target) {
@@ -38,10 +76,11 @@ function qwenCommandWrapper(name, description, target) {
   return `---\ndescription: "${desc}"\n---\n\n# ${name} (Qwen Command Adapter)\n\n> Adapter para Qwen Code. Fonte canonica: \`${target}\`.\n\nCANONICAL-SOURCE: ${target}\n\n## Adapter Contract\n\n1. Leia o arquivo canonico em **CANONICAL-SOURCE** por completo.\n2. Execute as instrucoes desse arquivo como fonte primaria.\n3. Argumentos do usuario: {{args}}`;
 }
 
-function claudeCommandWrapper(name, description, target, argumentHint) {
+function claudeCommandWrapper(name, description, target, argumentHint, ideLabel) {
   const desc = (description || name).replace(/"/g, '\\"').replace(/\n/g, ' ').slice(0, 200);
   const hint = argumentHint ? `\nargument-hint: "${argumentHint.replace(/"/g, '\\"')}"` : '\nargument-hint: "[argumentos opcionais]"';
-  return `---\ndescription: "${desc}"${hint}\n---\n\n# ${name} (Claude Adapter)\n\n> Adapter fino para Claude. Fonte canonica: \`${target}\`.\n\nCANONICAL-SOURCE: ${target}\n\n## Adapter Contract\n\n1. Leia o arquivo canonico indicado em **CANONICAL-SOURCE** por completo.\n2. Execute as instrucoes desse arquivo como fonte primaria.\n3. Argumentos do usuario: $ARGUMENTS`;
+  const label = ideLabel || 'Claude';
+  return `---\ndescription: "${desc}"${hint}\n---\n\n# ${name} (${label} Adapter)\n\n> Adapter fino para ${label}. Fonte canonica: \`${target}\`.\n\nCANONICAL-SOURCE: ${target}\n\n## Adapter Contract\n\n1. Leia o arquivo canonico indicado em **CANONICAL-SOURCE** por completo.\n2. Execute as instrucoes desse arquivo como fonte primaria.\n3. Argumentos do usuario: $ARGUMENTS`;
 }
 
 function extractAgentDescription(filePath) {
@@ -86,31 +125,59 @@ function main() {
   const agents = readJson(path.join(root, '.gos', 'agents', 'profiles', 'index.json')).profiles;
   const skills = readJson(path.join(root, '.gos', 'skills', 'registry.json')).skills;
 
+  cleanupStaleAdapters();
+
   for (const agent of agents) {
     const agentProfilePath = path.join(root, '.gos', 'agents', 'profiles', agent.path);
     const agentDesc = extractAgentDescription(agentProfilePath) || `${agent.id} agent`;
+    const aSlug = agentSlug(agent.id);
 
     // Claude commands (requires YAML frontmatter with description)
     const claudeFile = path.join(root, '.claude', 'commands', 'gos', 'agents', `${agent.id}.md`);
-    writeFile(claudeFile, claudeCommandWrapper(`gos-${agent.id}`, agentDesc, relativeTarget(claudeFile, agentProfilePath)));
+    writeFile(claudeFile, claudeCommandWrapper(aSlug, agentDesc, relativeTarget(claudeFile, agentProfilePath), '', 'Claude'));
 
     // Qwen commands (requires YAML frontmatter with description)
     const qwenCmd = path.join(root, '.qwen', 'commands', 'gos', 'agents', `${agent.id}.md`);
-    writeFile(qwenCmd, qwenCommandWrapper(`gos-${agent.id}`, agentDesc, relativeTarget(qwenCmd, agentProfilePath)));
+    writeFile(qwenCmd, qwenCommandWrapper(aSlug, agentDesc, relativeTarget(qwenCmd, agentProfilePath)));
 
     // Qwen sub-agents
-    const qwenAgent = path.join(root, '.qwen', 'agents', `gos-${agent.id}.md`);
+    const qwenAgent = path.join(root, '.qwen', 'agents', `${aSlug}.md`);
     const agentTarget = relativeTarget(qwenAgent, agentProfilePath);
     const safeDesc = agentDesc.replace(/"/g, '\\"').replace(/\n/g, ' ').slice(0, 200);
-    writeFile(qwenAgent, `---\nname: "gos-${agent.id}"\ndescription: "${safeDesc}"\nmodel: inherit\ntools:\n  - Read\n  - Glob\n  - Grep\n  - Bash\n  - Edit\n  - Write\n---\n\nFonte canonica: \`${agentTarget}\`\nLeia e siga o perfil em \`${agentTarget}\`.`);
+    writeFile(qwenAgent, `---\nname: "${aSlug}"\ndescription: "${safeDesc}"\nmodel: inherit\ntools:\n  - Read\n  - Glob\n  - Grep\n  - Bash\n  - Edit\n  - Write\n---\n\nFonte canonica: \`${agentTarget}\`\nLeia e siga o perfil em \`${agentTarget}\`.`);
+
+    // Codex commands (slash commands no Codex IDE Extension)
+    const codexCmd = path.join(root, '.codex', 'commands', 'gos', 'agents', `${agent.id}.md`);
+    writeFile(codexCmd, claudeCommandWrapper(aSlug, agentDesc, relativeTarget(codexCmd, agentProfilePath), '', 'Codex'));
+
+    // Codex sub-agents (Codex IDE espera .codex/agents/<id>.md)
+    const codexAgent = path.join(root, '.codex', 'agents', `${aSlug}.md`);
+    const codexAgentTarget = relativeTarget(codexAgent, agentProfilePath);
+    writeFile(codexAgent, `---\nname: "${aSlug}"\ndescription: "${safeDesc}"\nmodel: inherit\ntools:\n  - Read\n  - Glob\n  - Grep\n  - Bash\n  - Edit\n  - Write\n---\n\nFonte canonica: \`${codexAgentTarget}\`\nLeia e siga o perfil em \`${codexAgentTarget}\`.`);
+
+    // Codex / Antigravity (.agent/) / Gemini / Opencode usam namespace plano gos-<slug> em skills/.
+    // Agents aparecem no mesmo picker se emitidos como wrapper SKILL.md em skills/.
+    for (const ide of ['.codex', '.agent', '.gemini', '.opencode']) {
+      const ideAgentSkill = path.join(root, ide, 'skills', aSlug, 'SKILL.md');
+      writeFile(ideAgentSkill, skillWrapper(agent.id, relativeTarget(ideAgentSkill, agentProfilePath), agentDesc));
+    }
+
+    // Antigravity workflows (.agent/workflows/<id>.md) — slash command invocation no picker.
+    const antigravityWorkflow = path.join(root, '.agent', 'workflows', `${agent.id}.md`);
+    const workflowTarget = relativeTarget(antigravityWorkflow, agentProfilePath);
+    const safeAgentDesc = agentDesc.replace(/"/g, '\\"').replace(/\n/g, ' ').slice(0, 200);
+    writeFile(
+      antigravityWorkflow,
+      `---\ndescription: "${safeAgentDesc}"\n---\n\n# /${agent.id} (Antigravity Workflow)\n\nFonte canonica: \`${workflowTarget}\`\n\nLeia o arquivo canonico apontado em CANONICAL-SOURCE e execute as instrucoes como fonte primaria.\n\nCANONICAL-SOURCE: ${workflowTarget}\n\nArgumentos do usuario seguem o prompt do agente.`
+    );
   }
 
   for (const skill of skills) {
     const skillTargetPath = skill.skillFile || skill.path;
     const canonicalPath = path.join(root, '.gos', skillTargetPath);
     const claudeSkill = path.join(root, '.claude', 'commands', 'gos', 'skills', `${skill.slug}.md`);
-    const codexSkill = path.join(root, '.agents', 'skills', `gos-${skill.slug}`, 'SKILL.md');
-    const antigravitySkill = path.join(root, '.antigravity', 'skills', `gos-${skill.slug}`, 'SKILL.md');
+    const codexSkill = path.join(root, '.codex', 'skills', `gos-${skill.slug}`, 'SKILL.md');
+    const antigravitySkill = path.join(root, '.agent', 'skills', `gos-${skill.slug}`, 'SKILL.md');
     const geminiSkill = path.join(root, '.gemini', 'skills', `gos-${skill.slug}`, 'SKILL.md');
     const opencodeSkill = path.join(root, '.opencode', 'skills', `gos-${skill.slug}`, 'SKILL.md');
     const qwenSkill = path.join(root, '.qwen', 'skills', `gos-${skill.slug}`, 'SKILL.md');
@@ -121,7 +188,6 @@ function main() {
     const skillDesc = skillFm.description || skill.description || skill.name || skill.slug;
     const skillArgHint = skillFm['argument-hint'] || '';
 
-    writeFile(claudeSkill, skillWrapper(skill.slug, relativeTarget(claudeSkill, canonicalPath), skillDesc));
     writeFile(codexSkill, skillWrapper(skill.slug, relativeTarget(codexSkill, canonicalPath), skillDesc));
     writeFile(antigravitySkill, skillWrapper(skill.slug, relativeTarget(antigravitySkill, canonicalPath), skillDesc));
     writeFile(geminiSkill, skillWrapper(skill.slug, relativeTarget(geminiSkill, canonicalPath), skillDesc));
@@ -129,47 +195,97 @@ function main() {
     writeFile(qwenSkill, skillWrapper(skill.slug, relativeTarget(qwenSkill, canonicalPath), skillDesc));
 
     writeFile(qwenCmd, qwenCommandWrapper(`gos-${skill.slug}`, skillDesc, relativeTarget(qwenCmd, canonicalPath)));
-    writeFile(claudeSkill, claudeCommandWrapper(`gos-${skill.slug}`, skillDesc, relativeTarget(claudeSkill, canonicalPath), skillArgHint));
+    writeFile(claudeSkill, claudeCommandWrapper(`gos-${skill.slug}`, skillDesc, relativeTarget(claudeSkill, canonicalPath), skillArgHint, 'Claude'));
   }
 
-  const antigravityInstructions = [
-    '# G-OS Antigravity Instructions',
+  // Antigravity le AGENTS.md no root do workspace (ja existe no projeto).
+  // Skills vivem em .agent/skills/<slug>/SKILL.md (workspace scope, registrado acima no loop).
+  // Workflows (.agent/workflows/<id>.md) sao slash commands no picker da IDE.
+  // Rules opcionais em .agent/rules/ — nao geramos automaticamente (regras vivem no AGENTS.md).
+
+  // Codex IDE Extension — AGENTS.md + config.toml
+  // Codex e o ambiente de EXECUCAO (Opus planeja, Codex executa). Bloco abaixo garante
+  // que slash commands e subagents estao disponiveis ao abrir o projeto no Codex.
+  const codexAgentsMd = [
+    '# G-OS no Codex IDE Extension',
+    '',
+    'Este arquivo e auto-gerado por `npm run sync:ides`. Nao edite a mao.',
+    '',
+    'Codex IDE Extension e o ambiente de EXECUCAO do G-OS. Opus 4.7 planeja em outra IDE/sessao;',
+    'Codex executa task-a-task com `*execute-plan`.',
     '',
     'Leia sempre:',
-    '- `AGENTS.md`',
-    '- `CLAUDE.md`',
-    '- `.gos/docs/toolchain-map.md`',
+    '- `../AGENTS.md` (raiz do projeto)',
+    '- `../CLAUDE.md`',
+    '- `../.gos/docs/toolchain-map.md`',
+    '',
+    '## Execucao de planos (comando primario do Codex)',
+    '',
+    '```',
+    '*execute-plan PLAN-NNN-<slug>',
+    '```',
+    '',
+    'Ciclo: pre-flight visual -> loop por task com state machine -> visual gate -> validacao -> humano marca concluido.',
+    'Detalhes: `../.gos/skills/execute-plan/SKILL.md`.',
+    '',
+    '## Agents disponiveis',
+    '',
+    ...agents.map((agent) => `- \`gos-${agent.id}\` -> \`../.gos/agents/profiles/${agent.path}\``),
     '',
-    'Agentes disponiveis:',
-    ...agents.map((agent) => `- ${agent.id}`),
+    '## Skills curadas',
     '',
-    'Skills curadas:',
-    ...skills.map((skill) => `- ${skill.slug}`),
+    '| Slug | Arquivo canonico |',
+    '|------|------------------|',
+    ...skills.map((skill) => `| \`gos-${skill.slug}\` | \`../.gos/${skill.skillFile || skill.path}\` |`),
     '',
-    '## Como invocar Skills',
+    '## Como o Codex consome',
     '',
-    'Para usar uma skill, leia o arquivo canonico e siga suas instrucoes.',
-    'Skills tambem disponiveis como adapters em `.antigravity/skills/`.',
+    '- Slash commands em `.codex/commands/gos/{agents,skills}/<id>.md` -> unica superficie de skills/agents. Codex carrega o canonico apontado em CANONICAL-SOURCE e executa.',
+    '- Subagents em `.codex/agents/gos-<id>.md` -> declaracao de subagent (acessivel via Task tool e delegacao interna).',
+    '- Para invocar o orquestrador master, digite `/gos:agents:gos-master` no picker.',
+    ''
+  ].join('\n');
+  writeFile(path.join(root, '.codex', 'AGENTS.md'), codexAgentsMd);
+
+  const codexConfigToml = [
+    '# G-OS Codex IDE Extension config (auto-gerado por npm run sync:ides).',
+    '# Edite os arquivos canonicos em .gos/ ao inves deste.',
     '',
-    '| Skill | Arquivo canonico |',
-    '|-------|-----------------|',
-    ...skills.map((skill) => `| \`gos-${skill.slug}\` | \`.gos/${skill.skillFile || skill.path}\` |`)
+    'project = "g-os"',
+    'instructions = "AGENTS.md"',
+    '',
+    '[execution]',
+    'primary_command = "*execute-plan"',
+    'planning_command = "*plan"',
+    'progress_command = "*progress"',
+    'stack_command = "*stack"',
+    ''
   ].join('\n');
+  writeFile(path.join(root, '.codex', 'config.toml'), codexConfigToml);
 
-  writeFile(path.join(root, '.antigravity', 'instructions.md'), antigravityInstructions);
-  writeFile(
-    path.join(root, '.antigravity', 'config.json'),
-    JSON.stringify(
-      {
-        project: 'g-os',
-        instructions: ['instructions.md', '../AGENTS.md', '../CLAUDE.md']
-      },
-      null,
-      2
-    )
-  );
+  // Validacao final: garantir que os arquivos do Codex foram gerados.
+  // Evita regressoes silenciosas que ja quebraram a IDE no passado.
+  const codexFailures = [];
+  for (const agent of agents) {
+    const expectedAgent = path.join(root, '.codex', 'agents', `${agentSlug(agent.id)}.md`);
+    const expectedCmd = path.join(root, '.codex', 'commands', 'gos', 'agents', `${agent.id}.md`);
+    if (!fs.existsSync(expectedAgent)) codexFailures.push(expectedAgent);
+    if (!fs.existsSync(expectedCmd)) codexFailures.push(expectedCmd);
+  }
+  for (const skill of skills) {
+    const expectedSkill = path.join(root, '.codex', 'skills', `gos-${skill.slug}`, 'SKILL.md');
+    if (!fs.existsSync(expectedSkill)) codexFailures.push(expectedSkill);
+  }
+  if (!fs.existsSync(path.join(root, '.codex', 'AGENTS.md'))) codexFailures.push('.codex/AGENTS.md');
+  if (!fs.existsSync(path.join(root, '.codex', 'config.toml'))) codexFailures.push('.codex/config.toml');
+  if (codexFailures.length > 0) {
+    console.error(`[sync:ides] Codex IDE adapters incompletos. Faltando ${codexFailures.length} arquivos:`);
+    for (const f of codexFailures) console.error(`  - ${path.relative(root, f)}`);
+    process.exit(1);
+  }
 
   console.log(`Adapters generated for ${agents.length} agents and ${skills.length} skills.`);
+  console.log(`Codex IDE: ${agents.length} agents + ${skills.length} skills + AGENTS.md + config.toml.`);
 }
 
 main();