@thiagodiogo/pscode 2.2.2 → 2.4.0

package/dist/core/templates/workflows/grill-me.js

@@ -0,0 +1,64 @@
+export function getGrillMeSkillTemplate() {
+    return {
+        name: 'pscode-grill-me',
+        description: 'Interroga um plano antes da implementação — uma pergunta por vez, com resposta recomendada, explorando o código quando há evidência, até entendimento compartilhado. Use quando o usuário quer validar e refinar um plano antes de escrever artefatos ou código.',
+        instructions: getGrillMeInstructions(),
+        compatibility: 'Works with any pscode project.',
+        metadata: { author: 'pscode', version: '1.0' },
+    };
+}
+export function getGrillMeInstructions() {
+    return `Interrogue o plano do usuário até atingir entendimento compartilhado sobre o que realmente deve existir — não apenas sobre o que foi descrito. O objetivo é pressionar cada decisão e ambiguidade do plano **antes** de escrever qualquer artefato ou código.
+
+**Princípio central**: faça **uma pergunta por vez**. Nunca despeje uma lista de perguntas de uma só vez. Aguarde a resposta, incorpore-a ao seu entendimento e só então formule a próxima.
+
+**Steps**
+
+1. **Entenda o plano inicial**
+
+   Leia a descrição do usuário (e qualquer artefato/contexto já disponível). Identifique a árvore de decisões: requisitos, escopo, abordagem técnica, trade-offs e os pontos onde o plano está vago, ambíguo ou assume algo não dito.
+
+2. **Explore o código antes de perguntar**
+
+   Se uma pergunta pode ser respondida com evidência presente no próprio repositório (convenções existentes, padrões de arquitetura, como features semelhantes já foram feitas), **investigue o código** em vez de perguntar ao usuário. Use o resultado da investigação para formular perguntas melhores ou para já resolver a decisão.
+
+   Só pergunte ao usuário o que o código não responde — decisões de produto, prioridades, trade-offs e intenção.
+
+3. **Conduza a interrogação — uma pergunta por vez**
+
+   Para cada ponto não resolvido, na ordem em que as dependências entre decisões exigem (resolva primeiro o que destrava as demais):
+
+   - Faça **uma** pergunta clara e específica.
+   - Sempre acompanhe a pergunta com a **sua resposta recomendada** e um motivo curto — para orientar a decisão e permitir que o usuário apenas concorde e siga em frente quando a recomendação fizer sentido.
+   - Quando houver opções discretas, use a **ferramenta AskUserQuestion** com a recomendação como primeira opção (marcada como "(Recomendada)"). Para perguntas abertas, formule a recomendação no texto.
+   - Aguarde a resposta antes de prosseguir. Incorpore-a e reavalie a árvore de decisão: a resposta pode tornar perguntas seguintes desnecessárias ou abrir novas.
+
+4. **Navegue a árvore de decisão progressivamente**
+
+   À medida que cada decisão é resolvida, atualize seu entendimento e siga para a próxima decisão relevante. Não pergunte algo que já foi respondido (direta ou indiretamente) por uma resposta anterior ou pelo código.
+
+5. **Encerre por entendimento compartilhado**
+
+   Quando todos os ramos relevantes da árvore de decisão estiverem resolvidos e não restar ambiguidade material, **encerre a interrogação** e apresente um **resumo do entendimento compartilhado**: o que será construído, as decisões tomadas (com seus motivos) e os pontos explicitamente fora de escopo.
+
+   Confirme com o usuário que o resumo reflete o que deve existir. A partir daí, o plano está pronto para virar artefatos/implementação.
+
+**Guardrails**
+- Uma pergunta por vez — sempre. Nunca despeje várias perguntas juntas.
+- Toda pergunta vem com uma resposta recomendada.
+- Prefira investigar o código a perguntar, quando a resposta está no repositório.
+- Não invente decisões: se algo é genuinamente do usuário, pergunte.
+- Pare assim que houver entendimento compartilhado — não prolongue a interrogação além do necessário.
+- Se o usuário passou argumentos, trate-os como a descrição do plano a ser interrogado.
+`;
+}
+export function getGrillMeCommandTemplate() {
+    return {
+        name: 'PS: Grill Me',
+        description: 'Interroga um plano antes da implementação — uma pergunta por vez, com resposta recomendada, até entendimento compartilhado',
+        category: 'Workflow',
+        tags: ['grill', 'refinamento', 'plano', 'workflow'],
+        content: getGrillMeInstructions(),
+    };
+}
+//# sourceMappingURL=grill-me.js.map

package/dist/core/templates/workflows/propose.js

@@ -52,6 +52,18 @@ When ready to implement, run /ps:apply
 
    **IMPORTANT**: Do NOT proceed without understanding what the user wants to build.
 
+1b. **Fase de grill — interrogue o plano antes de gerar artefatos**
+
+   Antes de criar a change e gerar os artefatos, conduza a **fase de grill** para garantir que a proposta reflita o que realmente deve existir — não apenas a descrição inicial. Aplique o mesmo comportamento da skill \`grill-me\` (\`/ps:grill-me\`):
+
+   - Faça **uma pergunta por vez** — nunca despeje várias perguntas juntas. Aguarde a resposta antes da próxima.
+   - Acompanhe **cada** pergunta com a **sua resposta recomendada** e um motivo curto. Quando houver opções discretas, use a **ferramenta AskUserQuestion** com a recomendação como primeira opção ("(Recomendada)").
+   - **Explore o código quando há evidência**: se uma pergunta pode ser respondida pelo próprio repositório (convenções, padrões, features semelhantes), investigue o código em vez de perguntar. Só pergunte ao usuário decisões de produto, prioridades, trade-offs e intenção.
+   - Navegue a árvore de decisão progressivamente, resolvendo dependências; não repergunte o que já foi respondido pelo código ou por uma resposta anterior.
+   - Encerre quando houver **entendimento compartilhado** e apresente um resumo curto (o que será construído, decisões com motivos, fora de escopo) antes de seguir.
+
+   Os artefatos gerados a partir do Passo 2 SHALL refletir esse entendimento refinado.
+
 2. **Create the change directory**
    \`\`\`bash
    pscode new change "<name>"

package/dist/core/update.d.ts

@@ -38,26 +38,6 @@ export declare class UpdateCommand {
      * Displays a note about extra workflows installed that aren't in the active profile.
      */
     private displayExtraWorkflowsNote;
-    /**
-     * Removes skill directories for workflows when delivery changed to commands-only.
-     * Returns the number of directories removed.
-     */
-    private removeSkillDirs;
-    /**
-     * Removes skill directories for workflows that are no longer selected in the active profile.
-     * Returns the number of directories removed.
-     */
-    private removeUnselectedSkillDirs;
-    /**
-     * Removes command files for workflows when delivery changed to skills-only.
-     * Returns the number of files removed.
-     */
-    private removeCommandFiles;
-    /**
-     * Removes command files for workflows that are no longer selected in the active profile.
-     * Returns the number of files removed.
-     */
-    private removeUnselectedCommandFiles;
     /**
      * Detect and handle legacy Pscode artifacts.
      * Unlike init, update warns but continues if legacy files found in non-interactive mode.

package/dist/core/update.js

@@ -7,19 +7,18 @@
 import path from 'path';
 import chalk from 'chalk';
 import ora from 'ora';
-import * as fs from 'fs';
 import { createRequire } from 'module';
 import { FileSystemUtils } from '../utils/file-system.js';
 import { transformToHyphenCommands } from '../utils/command-references.js';
 import { AI_TOOLS, PSCODE_DIR_NAME } from './config.js';
 import { generateCommands, CommandAdapterRegistry, } from './command-generation/index.js';
-import { getToolVersionStatus, getSkillTemplates, getCommandContents, generateSkillContent, getToolsWithSkillsDir, } from './shared/index.js';
+import { getToolVersionStatus, getSkillTemplates, getCommandContents, generateSkillContent, getToolsWithSkillsDir, pruneOrphans, pruneOrphansForTool, } from './shared/index.js';
 import { detectLegacyArtifacts, cleanupLegacyArtifacts, formatCleanupSummary, formatDetectionSummary, getToolsFromLegacyArtifacts, } from './legacy-cleanup.js';
 import { isInteractive } from '../utils/interactive.js';
 import { getGlobalConfig } from './global-config.js';
-import { getProfileWorkflows, isValidProfile, DEFAULT_PROFILE, ALL_WORKFLOWS } from './profiles.js';
+import { getProfileWorkflows, isValidProfile, DEFAULT_PROFILE } from './profiles.js';
 import { getAvailableTools } from './available-tools.js';
-import { WORKFLOW_TO_SKILL_DIR, getCommandConfiguredTools, getConfiguredToolsForProfileSync, getToolsNeedingProfileSync, } from './profile-sync-drift.js';
+import { getCommandConfiguredTools, getConfiguredToolsForProfileSync, getToolsNeedingProfileSync, } from './profile-sync-drift.js';
 import { scanInstalledWorkflows as scanInstalledWorkflowsShared, migrateIfNeeded as migrateIfNeededShared, } from './migration.js';
 const require = createRequire(import.meta.url);
 const { version: PSCODE_VERSION } = require('../../package.json');
@@ -91,6 +90,15 @@ export class UpdateCommand {
         if (!this.force && toolsToUpdateSet.size === 0) {
             // All tools are up to date
             this.displayUpToDateMessage(toolStatuses);
+            // Even when up to date, prune orphan artifacts (e.g. skills/commands of
+            // workflows deleted or renamed in a previous version) by filesystem scan.
+            const pruned = pruneOrphans(resolvedProjectPath, configuredTools, desiredWorkflows, delivery);
+            if (pruned.removedSkillDirs > 0) {
+                console.log(chalk.dim(`Removed: ${pruned.removedSkillDirs} orphan skill directories`));
+            }
+            if (pruned.removedCommandFiles > 0) {
+                console.log(chalk.dim(`Removed: ${pruned.removedCommandFiles} orphan command files`));
+            }
             // Still check for new tool directories and extra workflows
             this.detectNewTools(resolvedProjectPath, configuredTools);
             this.displayExtraWorkflowsNote(resolvedProjectPath, configuredTools, desiredWorkflows);
@@ -132,11 +140,6 @@ export class UpdateCommand {
                         const skillContent = generateSkillContent(template, PSCODE_VERSION, transformer);
                         await FileSystemUtils.writeFile(skillFile, skillContent);
                     }
-                    removedDeselectedSkillCount += await this.removeUnselectedSkillDirs(skillsDir, desiredWorkflows);
-                }
-                // Delete skill directories if delivery is commands-only
-                if (!shouldGenerateSkills) {
-                    removedSkillCount += await this.removeSkillDirs(skillsDir);
                 }
                 // Generate commands if delivery includes commands
                 if (shouldGenerateCommands) {
@@ -147,12 +150,23 @@ export class UpdateCommand {
                             const commandFile = path.isAbsolute(cmd.path) ? cmd.path : path.join(resolvedProjectPath, cmd.path);
                             await FileSystemUtils.writeFile(commandFile, cmd.fileContent);
                         }
-                        removedDeselectedCommandCount += await this.removeUnselectedCommandFiles(resolvedProjectPath, toolId, desiredWorkflows);
                     }
                 }
-                // Delete command files if delivery is skills-only
-                if (!shouldGenerateCommands) {
-                    removedCommandCount += await this.removeCommandFiles(resolvedProjectPath, toolId);
+                // Prune by filesystem scan: remove any Pscode-managed skill dir or
+                // command file that is not desired for the active profile/delivery —
+                // including orphans of workflows deleted or renamed in the enum.
+                const pruned = pruneOrphansForTool(resolvedProjectPath, toolId, desiredWorkflows, delivery);
+                if (shouldGenerateSkills) {
+                    removedDeselectedSkillCount += pruned.removedSkillDirs;
+                }
+                else {
+                    removedSkillCount += pruned.removedSkillDirs;
+                }
+                if (shouldGenerateCommands) {
+                    removedDeselectedCommandCount += pruned.removedCommandFiles;
+                }
+                else {
+                    removedCommandCount += pruned.removedCommandFiles;
                 }
                 spinner.succeed(`Updated ${tool.name}`);
                 updatedTools.push(tool.name);
@@ -189,9 +203,9 @@ export class UpdateCommand {
         if (newlyConfiguredTools.length > 0) {
             console.log();
             console.log(chalk.bold('Getting started:'));
-            console.log('  /ps:new       Start a new change');
-            console.log('  /ps:continue  Create the next artifact');
+            console.log('  /ps:propose   Propose a new change');
             console.log('  /ps:apply     Implement tasks');
+            console.log('  /ps:complete  Finalize and archive a change');
             console.log();
             console.log(`Learn more: ${chalk.cyan('https://github.com/thiagodiogo/Pscode')}`);
         }
@@ -263,106 +277,6 @@ export class UpdateCommand {
             console.log(chalk.dim(`Note: ${extraWorkflows.length} extra workflows not in profile (use \`pscode config profile\` to switch profiles)`));
         }
     }
-    /**
-     * Removes skill directories for workflows when delivery changed to commands-only.
-     * Returns the number of directories removed.
-     */
-    async removeSkillDirs(skillsDir) {
-        let removed = 0;
-        for (const workflow of ALL_WORKFLOWS) {
-            const dirName = WORKFLOW_TO_SKILL_DIR[workflow];
-            if (!dirName)
-                continue;
-            const skillDir = path.join(skillsDir, dirName);
-            try {
-                if (fs.existsSync(skillDir)) {
-                    await fs.promises.rm(skillDir, { recursive: true, force: true });
-                    removed++;
-                }
-            }
-            catch {
-                // Ignore errors
-            }
-        }
-        return removed;
-    }
-    /**
-     * Removes skill directories for workflows that are no longer selected in the active profile.
-     * Returns the number of directories removed.
-     */
-    async removeUnselectedSkillDirs(skillsDir, desiredWorkflows) {
-        const desiredSet = new Set(desiredWorkflows);
-        let removed = 0;
-        for (const workflow of ALL_WORKFLOWS) {
-            if (desiredSet.has(workflow))
-                continue;
-            const dirName = WORKFLOW_TO_SKILL_DIR[workflow];
-            if (!dirName)
-                continue;
-            const skillDir = path.join(skillsDir, dirName);
-            try {
-                if (fs.existsSync(skillDir)) {
-                    await fs.promises.rm(skillDir, { recursive: true, force: true });
-                    removed++;
-                }
-            }
-            catch {
-                // Ignore errors
-            }
-        }
-        return removed;
-    }
-    /**
-     * Removes command files for workflows when delivery changed to skills-only.
-     * Returns the number of files removed.
-     */
-    async removeCommandFiles(projectPath, toolId) {
-        let removed = 0;
-        const adapter = CommandAdapterRegistry.get(toolId);
-        if (!adapter)
-            return 0;
-        for (const workflow of ALL_WORKFLOWS) {
-            const cmdPath = adapter.getFilePath(workflow);
-            const fullPath = path.isAbsolute(cmdPath) ? cmdPath : path.join(projectPath, cmdPath);
-            try {
-                if (fs.existsSync(fullPath)) {
-                    await fs.promises.unlink(fullPath);
-                    removed++;
-                }
-            }
-            catch {
-                // Ignore errors
-            }
-        }
-        return removed;
-    }
-    /**
-     * Removes command files for workflows that are no longer selected in the active profile.
-     * Returns the number of files removed.
-     */
-    async removeUnselectedCommandFiles(projectPath, toolId, desiredWorkflows) {
-        let removed = 0;
-        const adapter = CommandAdapterRegistry.get(toolId);
-        if (!adapter)
-            return 0;
-        const desiredSet = new Set(desiredWorkflows);
-        for (const workflow of ALL_WORKFLOWS) {
-            if (desiredSet.has(workflow))
-                continue;
-            const cmdPath = adapter.getFilePath(workflow);
-            const fullPath = path.isAbsolute(cmdPath) ? cmdPath : path.join(projectPath, cmdPath);
-            try {
-                if (fs.existsSync(fullPath)) {
-                    await fs.promises.unlink(fullPath);
-                    removed++;
-                }
-            }
-            catch {
-                // Ignore errors
-            }
-        }
-        return removed;
-    }
     /**
      * Detect and handle legacy Pscode artifacts.
      * Unlike init, update warns but continues if legacy files found in non-interactive mode.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thiagodiogo/pscode",
-  "version": "2.2.2",
+  "version": "2.4.0",
   "description": "AI-native system for spec-driven development",
   "keywords": [
     "pscode",

package/dist/core/templates/workflows/bulk-archive-change.d.ts

@@ -1,10 +0,0 @@
-/**
- * Skill Template Workflow Modules
- *
- * This file is generated by splitting the legacy monolithic
- * templates file into workflow-focused modules.
- */
-import type { SkillTemplate, CommandTemplate } from '../types.js';
-export declare function getBulkArchiveChangeSkillTemplate(): SkillTemplate;
-export declare function getPsBulkArchiveCommandTemplate(): CommandTemplate;
-//# sourceMappingURL=bulk-archive-change.d.ts.map