ganbatte-os 0.2.7 → 0.2.9

package/.gos/docs/curation.md

@@ -58,3 +58,21 @@ Foram mantidos apenas os suportes exigidos pelas skills copiadas:
 - memoria completa do framework
 - CLI legada do framework anterior
 - runtime multi-IDE integral
+
+## Decisoes de Curadoria
+
+### Lessons Loop / `tasks/lessons.md`
+
+O `G-OS` NAO ativa o loop de `tasks/lessons.md` e NAO replica o `Livro de Ouro` do framework principal.
+
+Motivos:
+
+- esta distribuicao nao inclui o subsistema completo de memoria do `.a8z-framework`
+- o custo de manter memoria graduada localmente aqui seria desproporcional ao escopo enxuto do `G-OS`
+- o ciclo canonico desta distribuicao permanece: `implementation_plan.md` -> `task.md` -> `walkthrough.md`
+
+Decisao operacional:
+
+- nao criar `tasks/lessons.md` neste repo
+- nao adicionar hooks de captura automatica de lessons
+- registrar aprendizados duraveis por curadoria manual em `docs/curation.md` ou promover direto para `rules/` quando houver padrao estavel

package/.gos/integrations/qwen/command-map.json

@@ -0,0 +1,20 @@
+{
+  "ide": "qwen-code",
+  "version": "1.0.0",
+  "status": "active",
+  "notes": {
+    "settingsFile": ".qwen/settings.json",
+    "skillsDir": ".qwen/skills/gos-{slug}/SKILL.md",
+    "agentsDir": ".qwen/agents/{id}.md",
+    "commandsDir": ".qwen/commands/",
+    "mcpConfig": "mcpServers object in .qwen/settings.json",
+    "ignoreFile": ".qwenignore"
+  },
+  "mappings": [
+    { "canonicalCommand": "gos.search", "coreArtifact": ".gos/prompts/01-search.md" },
+    { "canonicalCommand": "gos.spec", "coreArtifact": ".gos/prompts/02-spec.md" },
+    { "canonicalCommand": "gos.tasks", "coreArtifact": ".gos/prompts/03-tasks.md" },
+    { "canonicalCommand": "gos.code", "coreArtifact": ".gos/prompts/04-code.md" },
+    { "canonicalCommand": "gos.review", "coreArtifact": ".gos/prompts/05-reviews.md" }
+  ]
+}

package/.gos/integrations/registry.json

@@ -15,6 +15,7 @@
     "cursor": { "workspaceDir": ".cursor", "ruleFile": ".cursor/rules/g-os.mdc", "status": "active" },
     "codex": { "workspaceDir": ".codex", "adapter": "integrations/codex", "status": "active" },
     "opencode": { "workspaceDir": ".opencode", "adapter": "integrations/opencode", "status": "active" },
-    "kilo-code": { "workspaceDir": ".kilocode", "ruleFile": ".kilocode/rules/g-os.md", "status": "active" }
+    "kilo-code": { "workspaceDir": ".kilocode", "ruleFile": ".kilocode/rules/g-os.md", "status": "active" },
+    "qwen-code": { "workspaceDir": ".qwen", "adapter": "integrations/qwen", "status": "active" }
   }
 }

package/.gos/rules/demand-elegance.md

@@ -0,0 +1,38 @@
+---
+paths: "**"
+severity: INFO
+---
+
+# Demand Elegance
+
+## Resumo
+
+Agentes de IA devem buscar a solução mais elegante para problemas não-triviais, evitando soluções "hacky" ou excessivamente complexas. No entanto, deve haver um equilíbrio: para correções simples e óbvias, a velocidade e a simplicidade técnica prevalecem sobre o over-engineering.
+
+## Princípios
+
+1. **The Elegance Pause**: Para qualquer mudança que envolva decisões arquiteturais ou lógica complexa, o agente deve pausar internamente e perguntar: "Existe uma forma mais elegante de resolver isso?".
+2. **Hacky vs. Elegant**: Se um fix parece "remendado" (hacky), o agente deve propor a implementação da solução robusta e elegante, mesmo que exija um pouco mais de esforço inicial.
+3. **Over-engineering Guardrail**: Não crie abstrações desnecessárias para problemas simples. Se a solução óbvia é direta, use-a.
+4. **Refactoring Mindset**: Trate cada tarefa como uma oportunidade de deixar o código ligeiramente mais limpo do que o encontrou (Regra do Escoteiro).
+
+## Quando aplicar (The Elegance Gate)
+
+| Contexto | Ação |
+|----------|------|
+| **Bug Fix Crítico** | Direto ao ponto, correção robusta mas sem abstrações complexas. |
+| **Nova Feature** | Design elegante, modular e extensível por padrão. |
+| **Refatoração** | Máxima elegância, seguindo padrões de projeto e princípios SOLID. |
+| **Scripts Rápidos** | Funcionalidade sobre estética de código, desde que seguro. |
+
+## Exemplos
+
+### ❌ Inelegante (Hacky)
+Usar `setTimeout` arbitrário para esperar uma condição de rede sem retry-policy ou tratamento de erro adequado.
+
+### ✅ Elegante
+Implementar um padrão de `backoff exponencial` ou um `subscription mechanism` que reaja ao estado real do recurso.
+
+---
+
+*Baseado nos Core Principles do .a8z-OS.*

package/.gos/rules/plan-mode.md

@@ -20,7 +20,10 @@ Ativar **PLAN MODE** automaticamente sempre que o input do usuário envolver **q
 - Git operations: `commit`, `push`, `pull`, `branch`, `merge`, `status`, `log`
 - Leitura e explicação: "o que é", "como funciona", "onde está", "mostre", "explique"
 - Edições simples: 1 arquivo, 1 mudança isolada (ex: corrigir typo, ajustar 1 linha)
+- Correções de lint, typo, formatação, ortografia
 - Quando o usuário inclui: `"só faça"`, `"execute direto"`, `"sem plano"`, `"direto ao ponto"`
+- Comandos de retomada ou continuação: `"continue"`, `"continuar"`, `"retomar"`, `"resume"`, `"prosseguir"`, `"segue"`
+- Aprovações após um plano já apresentado: `"ok"`, `"aprovado"`, `"go"`, `"execute"`, `"pode ir"`, `"sim"`, `"proceed"`
 - Quando plan mode já foi ativado ou aprovado na sessão atual
 
 ---
@@ -37,7 +40,7 @@ Ativar **PLAN MODE** automaticamente sempre que o input do usuário envolver **q
   - Mudanças propostas agrupadas por componente
   - Arquivos a criar `[NEW]`, modificar `[MODIFY]`, deletar `[DELETE]`
   - Plano de verificação
-- **Apresentar o plano ao usuário e PARAR**
+- **Apresentar o plano ao usuário e aguardar aprovação na resposta principal, sem bloquear via hook**
 
 ### Fase 3 — AWAIT APPROVAL
 - Aguardar aprovação explícita do usuário (`"ok"`, `"aprovado"`, `"go"`, etc.)

package/.gos/scripts/hooks/claude-session-track.js

@@ -48,6 +48,9 @@ function readState(statePath, sessionId) {
       sessionId,
       touchedFiles: [],
       commands: [],
+      gitCommit: false,
+      lastCommitMessage: "",
+      taskRefs: [],
       significantAction: false,
       updatedAt: new Date().toISOString(),
     };
@@ -60,6 +63,9 @@ function readState(statePath, sessionId) {
       sessionId,
       touchedFiles: [],
       commands: [],
+      gitCommit: false,
+      lastCommitMessage: "",
+      taskRefs: [],
       significantAction: false,
       updatedAt: new Date().toISOString(),
     };
@@ -125,7 +131,19 @@ function main() {
   const toolName = String(payload.tool || payload.tool_name || payload.matcher || "");
   if (/Bash/i.test(toolName)) {
     const command = extractCommand(payload);
-    if (command) uniquePush(state.commands, command);
+    if (command) {
+      uniquePush(state.commands, command);
+      if (/\bgit\s+commit\b/i.test(command)) {
+        state.gitCommit = true;
+        const msgMatch = command.match(/-m\s+["']([^"']+)["']/);
+        if (msgMatch) {
+          const message = msgMatch[1].trim();
+          state.lastCommitMessage = message;
+          const refs = message.match(/\bT-\d{3}\b/g);
+          if (refs) state.taskRefs = [...new Set(refs)];
+        }
+      }
+    }
   }
 
   if (state.touchedFiles.length > 0 || state.commands.length > 0) {

package/.gos/scripts/hooks/claude-stop-summary.js

@@ -122,6 +122,22 @@ function main() {
   const summary = [];
   const syncMatcher = /^(\.gos|\.claude|data|README\.md|CLAUDE\.md|AGENTS\.md|GEMINI\.md)/;
 
+  // Trigger post-commit notification if git commit was made
+  if (state.gitCommit) {
+    try {
+      execFileSync('node', [path.join(ROOT, '.gos', 'scripts', 'hooks', 'post-commit-notify.js')], {
+        cwd: ROOT,
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: 30000,
+      })
+      summary.push('post-commit-notify OK')
+    } catch (error) {
+      const message = error.stderr || error.stdout || error.message || 'falha no post-commit'
+      summary.push(`post-commit-notify falhou (${String(message).split(/\r?\n/)[0]})`)
+    }
+  }
+
   if (anyPathMatches(touchedFiles, syncMatcher)) {
     try {
       runNpm(["run", "sync:ides"], { timeout: 180000 });

package/.gos/scripts/hooks/post-commit-notify.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+
+// post-commit-notify.js — Post-commit hook: marks tasks done in ClickUp + notifies Slack
+// Trigger: Claude Code Stop hook or git post-commit
+// Rule: ALWAYS exit 0 (observation hook, never blocks)
+
+const { execFileSync } = require('node:child_process')
+const { existsSync, readFileSync } = require('node:fs')
+const { resolve } = require('node:path')
+
+// Find repo root
+function findRepoRoot() {
+  try {
+    return execFileSync('git', ['rev-parse', '--show-toplevel'], { encoding: 'utf-8' }).trim()
+  } catch {
+    return process.cwd()
+  }
+}
+
+// Parse last commit
+function getLastCommit() {
+  try {
+    const log = execFileSync('git', ['log', '-1', '--format=%H|%s|%an'], { encoding: 'utf-8' }).trim()
+    const sepIdx = log.indexOf('|')
+    const hash = log.slice(0, sepIdx)
+    const rest = log.slice(sepIdx + 1)
+    const lastSep = rest.lastIndexOf('|')
+    const message = rest.slice(0, lastSep)
+    const author = rest.slice(lastSep + 1)
+    return { hash, message, author }
+  } catch {
+    return null
+  }
+}
+
+// Extract task refs from commit message (T-NNN pattern)
+function extractTaskRefs(message) {
+  const matches = message.match(/\bT-(\d{3})\b/g)
+  return matches ? [...new Set(matches)] : []
+}
+
+// Load sprint registry to resolve local IDs -> ClickUp IDs
+function loadRegistry(repoRoot) {
+  const paths = [
+    resolve(repoRoot, 'data/sprints/registry.json'),
+    resolve(repoRoot, '.gos/data/sprints/registry.json'),
+  ]
+  for (const p of paths) {
+    if (existsSync(p)) {
+      try {
+        return { data: JSON.parse(readFileSync(p, 'utf-8')), path: p }
+      } catch { continue }
+    }
+  }
+  return { data: { version: '1.0', sprints: [], taskMap: {}, taskSprintMap: {} }, path: paths[0] }
+}
+
+// Run a CLI tool safely (no shell injection)
+function runTool(repoRoot, tool, toolArgs) {
+  const toolPaths = [
+    resolve(repoRoot, `.gos/scripts/tools/${tool}`),
+    resolve(repoRoot, `scripts/tools/${tool}`),
+  ]
+  const toolPath = toolPaths.find(p => existsSync(p))
+  if (!toolPath) return null
+
+  try {
+    const result = execFileSync('node', [toolPath, ...toolArgs], {
+      encoding: 'utf-8',
+      timeout: 15000,
+      env: process.env,
+    })
+    return JSON.parse(result)
+  } catch (e) {
+    return { error: e.message }
+  }
+}
+
+// Detect if commit implies task completion
+function isCompletionCommit(message) {
+  const completionPatterns = [
+    /^feat[:(]/i,
+    /^fix[:(]/i,
+    /\b(close[sd]?|complete[sd]?|finish|done|resolve[sd]?)\b/i,
+  ]
+  return completionPatterns.some(p => p.test(message))
+}
+
+// Detect if commit is a start/WIP commit
+function isStartCommit(message) {
+  const startPatterns = [
+    /^(wip|chore|progress|draft|start|refactor|test|docs|style)[:(]/i,
+    /\b(wip|in.?progress|draft|start)\b/i,
+  ]
+  return startPatterns.some(p => p.test(message))
+}
+
+// Find sprint for a task reference
+function findSprintForTask(registry, taskRef) {
+  if (registry.taskSprintMap?.[taskRef]) {
+    return registry.sprints.find(s => s.id === registry.taskSprintMap[taskRef]) || null
+  }
+  return registry.sprints.filter(s => !s.end || new Date(s.end) >= new Date())
+    .sort((a, b) => new Date(b.start) - new Date(a.start))[0] || null
+}
+
+async function main() {
+  const repoRoot = findRepoRoot()
+  const commit = getLastCommit()
+  if (!commit) return
+
+  const taskRefs = extractTaskRefs(commit.message)
+  if (taskRefs.length === 0) return
+
+  const hasClickUp = !!process.env.CLICKUP_API_KEY
+  const hasSlack = !!process.env.SLACK_WEBHOOK_URL
+  if (!hasClickUp && !hasSlack) return
+
+  const { data: registry } = loadRegistry(repoRoot)
+  const shouldComplete = isCompletionCommit(commit.message)
+  const shouldStart = isStartCommit(commit.message)
+
+  for (const ref of taskRefs) {
+    const clickupId = registry.taskMap?.[ref]
+
+    // Update ClickUp task status
+    if (hasClickUp && clickupId) {
+      if (shouldComplete) {
+        runTool(repoRoot, 'clickup.js', ['task', 'update', '--task-id', clickupId, '--status', 'complete'])
+      } else if (shouldStart) {
+        runTool(repoRoot, 'clickup.js', ['task', 'update', '--task-id', clickupId, '--status', 'in progress'])
+      }
+    }
+
+    // Notify Slack
+    if (hasSlack) {
+      const status = shouldComplete ? 'concluida' : shouldStart ? 'em andamento' : 'atualizada'
+      runTool(repoRoot, 'slack-notify.js', [
+        'task-update',
+        '--task', ref,
+        '--status', status,
+        '--commit', commit.hash,
+        '--author', commit.author,
+        '--message', commit.message,
+      ])
+    }
+
+    // Sprint completion check (if task completed)
+    if (shouldComplete) {
+      const sprint = findSprintForTask(registry, ref)
+      if (sprint) {
+        const tasksInSprint = Object.entries(registry.taskSprintMap || {})
+          .filter(([, sid]) => sid === sprint.id)
+          .map(([tid]) => tid)
+        const completedTasks = tasksInSprint.filter(tid => {
+          const cuId = registry.taskMap?.[tid]
+          if (!cuId) return false
+          return true
+        })
+        if (tasksInSprint.length > 0 && completedTasks.length === tasksInSprint.length) {
+          if (hasSlack) {
+            runTool(repoRoot, 'slack-notify.js', [
+              'sprint-complete',
+              '--sprint', sprint.id,
+              '--name', sprint.name,
+              '--tasks', tasksInSprint.join(', '),
+            ])
+          }
+        }
+      }
+    }
+  }
+}
+
+main().catch(() => {}).finally(() => process.exit(0))

package/.gos/scripts/integrations/check-ide-compat.js

@@ -20,7 +20,8 @@ const required = [
   '.gos/integrations/antigravity/command-map.json',
   '.gos/integrations/gemini/command-map.json',
   '.gos/integrations/cursor/command-map.json',
-  '.gos/integrations/kilo-code/command-map.json'
+  '.gos/integrations/kilo-code/command-map.json',
+  '.gos/integrations/qwen/command-map.json'
 ];
 
 const missing = required.filter((entry) => !fs.existsSync(path.join(root, entry)));

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

@@ -46,11 +46,14 @@ function main() {
     const codexSkill = path.join(root, '.codex', 'skills', `gos-${skill.slug}.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');
 
     writeFile(claudeSkill, skillWrapper(skill.slug, relativeTarget(claudeSkill, path.join(root, '.gos', skillTargetPath))));
     writeFile(codexSkill, skillWrapper(skill.slug, relativeTarget(codexSkill, path.join(root, '.gos', skillTargetPath))));
     writeFile(geminiSkill, skillWrapper(skill.slug, relativeTarget(geminiSkill, path.join(root, '.gos', skillTargetPath))));
     writeFile(opencodeSkill, skillWrapper(skill.slug, relativeTarget(opencodeSkill, path.join(root, '.gos', skillTargetPath))));
+    ensureDir(path.dirname(qwenSkill));
+    writeFile(qwenSkill, skillWrapper(skill.slug, relativeTarget(qwenSkill, path.join(root, '.gos', skillTargetPath))));
   }
 
   const antigravityInstructions = [

package/.gos/scripts/tools/slack-notify.js

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+
+// slack-notify.js — Slack notification tool via Incoming Webhooks (zero-dep)
+// Usage: node slack-notify.js <command> [--options]
+// Auth: SLACK_WEBHOOK_URL env var (Incoming Webhook URL)
+
+const WEBHOOK_URL = process.env.SLACK_WEBHOOK_URL
+
+if (!WEBHOOK_URL) {
+  // Graceful skip — no webhook configured is not an error
+  console.log(JSON.stringify({ skipped: true, reason: 'SLACK_WEBHOOK_URL not set' }))
+  process.exit(0)
+}
+
+function parseArgs(argv) {
+  const result = { _: [] }
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]
+    if (arg.startsWith('--')) {
+      const key = arg.slice(2)
+      const next = argv[i + 1]
+      if (next && !next.startsWith('--')) {
+        result[key] = next
+        i++
+      } else {
+        result[key] = true
+      }
+    } else {
+      result._.push(arg)
+    }
+  }
+  return result
+}
+
+const args = parseArgs(process.argv.slice(2))
+const [cmd, sub, ...rest] = args._
+
+async function sendWebhook(payload) {
+  if (args['dry-run']) {
+    return { _dry_run: true, url: WEBHOOK_URL.replace(/\/[^/]{6,}$/, '/***'), payload }
+  }
+
+  const res = await fetch(WEBHOOK_URL, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(payload),
+  })
+
+  const text = await res.text()
+  if (res.ok) {
+    return { sent: true, status: res.status }
+  }
+  return { sent: false, status: res.status, body: text }
+}
+
+function escapeSlack(text) {
+  return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+}
+
+function buildTaskDonePayload(taskId, commit, author, extra = {}) {
+  const sprint = extra.sprint || ''
+  const track = extra.track || ''
+  const message = extra.message || ''
+
+  const lines = [`*:white_check_mark: Task Concluída*`]
+  lines.push(`>*Task:* ${escapeSlack(taskId)}${message ? ` — ${escapeSlack(message)}` : ''}`)
+  if (sprint) lines.push(`>*Sprint:* ${escapeSlack(sprint)}`)
+  if (track) lines.push(`>*Track:* ${escapeSlack(track)}`)
+  lines.push(`>*Commit:* \`${escapeSlack(commit.slice(0, 7))}\`${message ? ` — ${escapeSlack(message)}` : ''}`)
+  lines.push(`>*Author:* ${escapeSlack(author)}`)
+
+  return { text: lines.join('\n') }
+}
+
+function buildSprintSummaryPayload(data) {
+  const summary = data.summary || data
+  const name = data.sprint?.name || data.name || 'Sprint'
+  const now = Math.floor(Date.now() / 1000)
+
+  return {
+    blocks: [
+      {
+        type: 'header',
+        text: { type: 'plain_text', text: `:bar_chart: ${name} — Status Update` }
+      },
+      {
+        type: 'section',
+        fields: [
+          { type: 'mrkdwn', text: `*Total:*\n${summary.totalTasks || 0} tasks` },
+          { type: 'mrkdwn', text: `*Done:*\n${summary.done || 0} (${summary.completionPct || 0}%)` }
+        ]
+      },
+      {
+        type: 'section',
+        fields: [
+          { type: 'mrkdwn', text: `*In Progress:*\n${summary.inProgress || 0}` },
+          { type: 'mrkdwn', text: `*Blocked:*\n${summary.blocked || 0}` }
+        ]
+      },
+      { type: 'divider' },
+      {
+        type: 'context',
+        elements: [
+          { type: 'mrkdwn', text: `Updated: <!date^${now}^{date_short} {time}|${new Date().toISOString()}>` }
+        ]
+      }
+    ]
+  }
+}
+
+async function main() {
+  let result
+
+  switch (cmd) {
+    case 'send': {
+      if (args.text) {
+        result = await sendWebhook({ text: args.text })
+      } else if (args['blocks-file']) {
+        const { readFileSync } = require('node:fs')
+        try {
+          const payload = JSON.parse(readFileSync(args['blocks-file'], 'utf-8'))
+          result = await sendWebhook(payload)
+        } catch (e) {
+          result = { error: `Failed to read ${args['blocks-file']}: ${e.message}` }
+        }
+      } else {
+        result = { error: '--text or --blocks-file required' }
+      }
+      break
+    }
+
+    case 'task-done': {
+      if (!args.task || !args.commit || !args.author) {
+        result = { error: '--task, --commit, and --author required' }; break
+      }
+      const payload = buildTaskDonePayload(args.task, args.commit, args.author, {
+        sprint: args.sprint,
+        track: args.track,
+        message: args.message,
+      })
+      result = await sendWebhook(payload)
+      break
+    }
+
+    case 'sprint-summary': {
+      if (!args.file) { result = { error: '--file (sprint status JSON) required' }; break }
+      const { readFileSync } = require('node:fs')
+      try {
+        const data = JSON.parse(readFileSync(args.file, 'utf-8'))
+        const payload = buildSprintSummaryPayload(data)
+        result = await sendWebhook(payload)
+      } catch (e) {
+        result = { error: `Failed to read ${args.file}: ${e.message}` }
+      }
+      break
+    }
+
+    default:
+      result = {
+        error: cmd ? `Unknown command: ${cmd}` : 'No command provided',
+        usage: {
+          send: 'send --text "Hello *bold* _italic_" | send --blocks-file payload.json',
+          'task-done': 'task-done --task T-001 --commit abc1234 --author "Name" [--sprint "S01"] [--track backend] [--message "feat: ..."]',
+          'sprint-summary': 'sprint-summary --file sprint-status.json',
+        },
+        formatting: {
+          bold: '*text*',
+          italic: '_text_',
+          strike: '~text~',
+          code: '`code`',
+          codeBlock: '```multi-line```',
+          quote: '>quoted text',
+          link: '<url|display text>',
+          mention: '<@USER_ID>',
+          channel: '<#CHANNEL_ID>',
+          date: '<!date^UNIX_TS^{date_short} {time}|fallback>',
+        },
+        flags: {
+          '--dry-run': 'Show payload without sending',
+        }
+      }
+  }
+
+  console.log(JSON.stringify(result, null, 2))
+}
+
+main().catch(err => {
+  console.error(JSON.stringify({ error: err.message }))
+  process.exit(0) // Always exit 0 — notification failure should never block
+})

package/AGENTS.md

@@ -39,8 +39,8 @@ Antes de executar qualquer tarefa complexa, SEMPRE entre em plan mode.
 
 **Protocolo:**
 1. **RESEARCH** — leia arquivos relevantes sem alterar nada
-2. **PLAN** — crie `implementation_plan.md` com `[NEW]`/`[MODIFY]`/`[DELETE]`, perguntas abertas, plano de verificação. Apresente e **PARE**
+2. **PLAN** — crie `implementation_plan.md` com `[NEW]`/`[MODIFY]`/`[DELETE]`, perguntas abertas, plano de verificação. Apresente e aguarde aprovação na resposta principal, sem bloquear via hook
 3. **AWAIT** — aguarde aprovação: "ok", "aprovado", "go", "execute", "pode ir"
 4. **EXECUTE + TRACK** — crie `task.md`, execute, finalize com `walkthrough.md`
 
-**Exceções — NÃO ativar:** git operations, leitura/explicação, edições simples de 1 arquivo, lint/typo, "execute direto", "sem plano", quando já aprovado na sessão.
+**Exceções — NÃO ativar:** git operations, leitura/explicação, edições simples de 1 arquivo, lint/typo, "execute direto", "sem plano", comandos de retomada como `continue`/`continuar`/`resume`, aprovações como `ok`/`aprovado`/`pode ir`, quando já aprovado na sessão.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ganbatte-os",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "Framework operacional para design-to-code, squads de entrega e sprint sync com ClickUp.",
   "bin": {
     "ganbatte-os": ".gos/scripts/cli/gos-cli.js",