@thiagodiogo/pscode 2.1.0 → 2.2.0

package/dist/cli/index.js

@@ -76,6 +76,8 @@ program
     .option('--tools <tools>', toolsOptionDescription)
     .option('--force', 'Auto-cleanup legacy files without prompting')
     .option('--profile <profile>', 'Workflow profile to use (core, full, trello)')
+    .option('--pr', 'Enable PR workflow config without interactive prompts (uses defaults: branch=feat/{change-name}, title=[{type}] {change-name})')
+    .option('--no-pr', 'Disable PR workflow config without interactive prompts')
     .action(async (targetPath = '.', options) => {
     try {
         // Validate that the path is a valid directory
@@ -103,6 +105,7 @@ program
             tools: options?.tools,
             force: options?.force,
             profile: options?.profile,
+            pr: options?.pr,
         });
         await initCommand.execute(targetPath);
     }

package/dist/core/completions/command-registry.js

@@ -22,6 +22,14 @@ export const COMMAND_REGISTRY = [
                 takesValue: true,
                 values: ['standard', 'dixi'],
             },
+            {
+                name: 'pr',
+                description: 'Enable PR workflow config without interactive prompts',
+            },
+            {
+                name: 'no-pr',
+                description: 'Disable PR workflow config without interactive prompts',
+            },
         ],
     },
     {

package/dist/core/config-prompts.d.ts

@@ -2,7 +2,7 @@ import type { ProjectConfig } from './project-config.js';
 /**
  * Serialize config to YAML string with helpful comments.
  *
- * @param config - Partial config object (schema required, context/rules optional)
+ * @param config - Partial config object (schema required, context/rules/pr optional)
  * @returns YAML string ready to write to file
  */
 export declare function serializeConfig(config: Partial<ProjectConfig>): string;

package/dist/core/config-prompts.js

@@ -1,7 +1,8 @@
+import { stringify as stringifyYaml } from 'yaml';
 /**
  * Serialize config to YAML string with helpful comments.
  *
- * @param config - Partial config object (schema required, context/rules optional)
+ * @param config - Partial config object (schema required, context/rules/pr optional)
  * @returns YAML string ready to write to file
  */
 export function serializeConfig(config) {
@@ -9,6 +10,12 @@ export function serializeConfig(config) {
     // Schema (required)
     lines.push(`schema: ${config.schema}`);
     lines.push('');
+    // PR workflow config (if present)
+    if (config.pr !== undefined) {
+        const prYaml = stringifyYaml({ pr: config.pr }, { lineWidth: 0 });
+        lines.push(prYaml.trimEnd());
+        lines.push('');
+    }
     // Context section with comments
     lines.push('# Project context (optional)');
     lines.push('# This is shown to AI when creating artifacts.');

package/dist/core/init.d.ts

@@ -9,12 +9,14 @@ type InitCommandOptions = {
     force?: boolean;
     interactive?: boolean;
     profile?: string;
+    pr?: boolean;
 };
 export declare class InitCommand {
     private readonly toolsArg?;
     private readonly force;
     private readonly interactiveOption?;
     private readonly profileOverride?;
+    private readonly prFlag?;
     constructor(options?: InitCommandOptions);
     execute(targetPath: string): Promise<void>;
     private validate;
@@ -28,6 +30,7 @@ export declare class InitCommand {
     private resolveToolsArg;
     private validateTools;
     private handleTrelloSetup;
+    private handlePrSetup;
     private createDirectoryStructure;
     private generateSkillsAndCommands;
     private createConfig;

package/dist/core/init.js

@@ -24,8 +24,10 @@ import { getGlobalConfig } from './global-config.js';
 import { getProfileWorkflows, isValidProfile, DEFAULT_PROFILE, PROFILES, ALL_WORKFLOWS } from './profiles.js';
 import { detectDixiStack, getDixiStackFamily, getDixiStackLabel, installDixiExtras } from './presets/dixi.js';
 import { stringify as stringifyYaml } from 'yaml';
+import { parse as parseYaml } from 'yaml';
 import { getAvailableTools } from './available-tools.js';
 import { migrateIfNeeded } from './migration.js';
+import { runPrInitPrompt } from './pr-init-prompt.js';
 const require = createRequire(import.meta.url);
 const { version: PSCODE_VERSION } = require('../../package.json');
 // -----------------------------------------------------------------------------
@@ -50,6 +52,8 @@ const WORKFLOW_TO_SKILL_DIR = {
     // Trello-specific workflows
     'trello-setup': 'pscode-trello-setup',
     'draft': 'pscode-trello-draft',
+    // Productivity workflows
+    'handoff': 'pscode-handoff',
     // Dixi-specific workflows
     'rfc': 'pscode-dixi-rfc',
     'design': 'pscode-dixi-design',
@@ -67,11 +71,13 @@ export class InitCommand {
     force;
     interactiveOption;
     profileOverride;
+    prFlag;
     constructor(options = {}) {
         this.toolsArg = options.tools;
         this.force = options.force ?? false;
         this.interactiveOption = options.interactive;
         this.profileOverride = options.profile;
+        this.prFlag = options.pr;
     }
     async execute(targetPath) {
         const projectPath = path.resolve(targetPath);
@@ -108,6 +114,8 @@ export class InitCommand {
         await this.createDirectoryStructure(pscodePath, extendMode);
         // Trello integration setup (interactive mode only)
         const trelloConfigured = await this.handleTrelloSetup(pscodePath);
+        // PR workflow setup (interactive or via flags)
+        const prConfig = await this.handlePrSetup(pscodePath, extendMode);
         // Generate skills and commands for each tool
         const results = await this.generateSkillsAndCommands(projectPath, validatedTools);
         // Dixi profile extras: stack detection and .pscode-dixi.yaml
@@ -118,7 +126,7 @@ export class InitCommand {
             await this.generateJiraFiles(projectPath);
         }
         // Create config.yaml if needed
-        const configStatus = await this.createConfig(pscodePath, extendMode);
+        const configStatus = await this.createConfig(pscodePath, extendMode, prConfig ?? undefined);
         // Display success message
         this.displaySuccessMessage(projectPath, validatedTools, results, configStatus, trelloConfigured);
     }
@@ -405,6 +413,51 @@ export class InitCommand {
         }
     }
     // ═══════════════════════════════════════════════════════════
+    // PR WORKFLOW SETUP
+    // ═══════════════════════════════════════════════════════════
+    async handlePrSetup(pscodePath, extendMode) {
+        // --pr flag: enable PR without prompts (default values)
+        if (this.prFlag === true) {
+            return {
+                enabled: true,
+                branch: { pattern: 'feat/{change-name}' },
+                title: { template: '[{type}] {change-name}' },
+                description: { template: '## O que foi feito\n\n\n## Como testar\n\n\n## Referências\n' },
+                comments: { linkInTask: true },
+            };
+        }
+        // --no-pr flag: disable PR without prompts
+        if (this.prFlag === false) {
+            return { enabled: false };
+        }
+        // Non-interactive mode with no flag: skip PR config
+        if (!this.canPromptInteractively()) {
+            return null;
+        }
+        // Interactive mode: if config exists, ask if user wants to reconfigure PR
+        if (extendMode) {
+            const configPath = path.join(pscodePath, 'config.yaml');
+            const configYmlPath = path.join(pscodePath, 'config.yml');
+            const configExists = fs.existsSync(configPath) || fs.existsSync(configYmlPath);
+            if (configExists) {
+                const { confirm } = await import('@inquirer/prompts');
+                const wantsReconfigure = await confirm({
+                    message: 'Reconfigurar preferências de PR?',
+                    default: false,
+                });
+                if (!wantsReconfigure) {
+                    return null; // Preserve existing PR config
+                }
+            }
+        }
+        try {
+            return await runPrInitPrompt();
+        }
+        catch {
+            return null;
+        }
+    }
+    // ═══════════════════════════════════════════════════════════
     // DIRECTORY STRUCTURE
     // ═══════════════════════════════════════════════════════════
     async createDirectoryStructure(pscodePath, extendMode) {
@@ -522,16 +575,36 @@ export class InitCommand {
     // ═══════════════════════════════════════════════════════════
     // CONFIG FILE
     // ═══════════════════════════════════════════════════════════
-    async createConfig(pscodePath, extendMode) {
+    async createConfig(pscodePath, extendMode, prConfig) {
         const configPath = path.join(pscodePath, 'config.yaml');
         const configYmlPath = path.join(pscodePath, 'config.yml');
         const configYamlExists = fs.existsSync(configPath);
         const configYmlExists = fs.existsSync(configYmlPath);
         if (configYamlExists || configYmlExists) {
+            // If PR config was provided, merge it into the existing file
+            if (prConfig !== undefined) {
+                try {
+                    const existingPath = configYamlExists ? configPath : configYmlPath;
+                    const raw = parseYaml(fs.readFileSync(existingPath, 'utf-8'));
+                    const existingSchema = (raw && typeof raw.schema === 'string') ? raw.schema : DEFAULT_SCHEMA;
+                    const globalConfig = getGlobalConfig();
+                    const resolvedProfile = this.resolveProfileOverride() ?? (isValidProfile(globalConfig.profile ?? '') ? globalConfig.profile : DEFAULT_PROFILE);
+                    const schema = existingSchema || (resolvedProfile === 'dixi' ? 'pstld-workflow' : DEFAULT_SCHEMA);
+                    const yamlContent = serializeConfig({ schema, pr: prConfig });
+                    await FileSystemUtils.writeFile(configPath, yamlContent);
+                    return 'updated';
+                }
+                catch {
+                    return 'exists';
+                }
+            }
             return 'exists';
         }
         try {
-            const yamlContent = serializeConfig({ schema: DEFAULT_SCHEMA });
+            const globalConfig = getGlobalConfig();
+            const resolvedProfile = this.resolveProfileOverride() ?? (isValidProfile(globalConfig.profile ?? '') ? globalConfig.profile : DEFAULT_PROFILE);
+            const schema = resolvedProfile === 'dixi' ? 'pstld-workflow' : DEFAULT_SCHEMA;
+            const yamlContent = serializeConfig({ schema, pr: prConfig });
             await FileSystemUtils.writeFile(configPath, yamlContent);
             return 'created';
         }
@@ -589,7 +662,13 @@ export class InitCommand {
         }
         // Config status
         if (configStatus === 'created') {
-            console.log(`Config: pscode/config.yaml (schema: ${DEFAULT_SCHEMA})`);
+            const globalCfgForSchema = getGlobalConfig();
+            const profileForSchema = this.resolveProfileOverride() ?? (isValidProfile(globalCfgForSchema.profile ?? '') ? globalCfgForSchema.profile : DEFAULT_PROFILE);
+            const createdSchema = profileForSchema === 'dixi' ? 'pstld-workflow' : DEFAULT_SCHEMA;
+            console.log(`Config: pscode/config.yaml (schema: ${createdSchema})`);
+        }
+        else if (configStatus === 'updated') {
+            console.log(`Config: pscode/config.yaml (updated with PR config)`);
         }
         else if (configStatus === 'exists') {
             // Show actual filename (config.yaml or config.yml)

package/dist/core/pr-init-prompt.d.ts

@@ -0,0 +1,13 @@
+/**
+ * PR Init Prompt
+ *
+ * Handles the interactive PR workflow configuration questions during `pscode init`.
+ * Collects branch pattern, PR title/description templates, and tracker comment settings.
+ */
+import type { PrConfig } from './project-config.js';
+/**
+ * Runs the interactive PR configuration questions during `pscode init`.
+ * Returns the collected PrConfig, or null if the user opts out.
+ */
+export declare function runPrInitPrompt(): Promise<PrConfig | null>;
+//# sourceMappingURL=pr-init-prompt.d.ts.map

package/dist/core/pr-init-prompt.js

@@ -0,0 +1,76 @@
+/**
+ * PR Init Prompt
+ *
+ * Handles the interactive PR workflow configuration questions during `pscode init`.
+ * Collects branch pattern, PR title/description templates, and tracker comment settings.
+ */
+import chalk from 'chalk';
+const DEFAULT_BRANCH_PATTERN = 'feat/{change-name}';
+const DEFAULT_TITLE_TEMPLATE = '[{type}] {change-name}';
+const DEFAULT_DESCRIPTION_TEMPLATE = '## O que foi feito\n\n\n## Como testar\n\n\n## Referências\n';
+/**
+ * Runs the interactive PR configuration questions during `pscode init`.
+ * Returns the collected PrConfig, or null if the user opts out.
+ */
+export async function runPrInitPrompt() {
+    const { confirm, input } = await import('@inquirer/prompts');
+    console.log();
+    console.log(chalk.bold('Workflow de PR'));
+    console.log(chalk.dim('  Configure padrões de branch, título e descrição para Pull Requests.'));
+    console.log(chalk.dim('  Template variables: {change-name}, {type}, {ticket}'));
+    console.log();
+    const wantsPr = await confirm({
+        message: 'Usar workflow de PR neste projeto? (branch dedicada + PR obrigatório)',
+        default: false,
+    });
+    if (!wantsPr) {
+        return { enabled: false };
+    }
+    const branchPattern = await input({
+        message: 'Padrão de nome de branch:',
+        default: DEFAULT_BRANCH_PATTERN,
+    });
+    const titleTemplate = await input({
+        message: 'Template de título do PR:',
+        default: DEFAULT_TITLE_TEMPLATE,
+    });
+    const useDefaultDescription = await confirm({
+        message: 'Usar template padrão de descrição de PR?',
+        default: true,
+    });
+    let descriptionTemplate;
+    if (useDefaultDescription) {
+        descriptionTemplate = DEFAULT_DESCRIPTION_TEMPLATE;
+    }
+    else {
+        const customDesc = await input({
+            message: 'Caminho para arquivo .md com template de descrição (ou deixe vazio para usar o padrão):',
+            default: '',
+        });
+        if (customDesc.trim()) {
+            try {
+                const { readFileSync } = await import('fs');
+                descriptionTemplate = readFileSync(customDesc.trim(), 'utf-8');
+            }
+            catch {
+                console.log(chalk.yellow(`  Arquivo não encontrado — usando template padrão.`));
+                descriptionTemplate = DEFAULT_DESCRIPTION_TEMPLATE;
+            }
+        }
+        else {
+            descriptionTemplate = DEFAULT_DESCRIPTION_TEMPLATE;
+        }
+    }
+    const linkInTask = await confirm({
+        message: 'Comentar link do PR na tarefa (Trello/Jira)?',
+        default: true,
+    });
+    return {
+        enabled: true,
+        branch: { pattern: branchPattern.trim() || DEFAULT_BRANCH_PATTERN },
+        title: { template: titleTemplate.trim() || DEFAULT_TITLE_TEMPLATE },
+        description: { template: descriptionTemplate },
+        comments: { linkInTask },
+    };
+}
+//# sourceMappingURL=pr-init-prompt.js.map

package/dist/core/presets/dixi.d.ts

@@ -28,5 +28,6 @@ export declare function applyFeatureSlicedSkeleton(projectRoot: string): {
     skipped: number;
 };
 export declare function installEslintArchitectureTemplate(projectRoot: string): void;
+export declare function copyDixiCommands(destRoot: string, srcDir: string, subdir: string): void;
 export declare function installDixiExtras(projectDir: string, stack: DixiStack | null): void;
 //# sourceMappingURL=dixi.d.ts.map

package/dist/core/presets/dixi.js

@@ -141,8 +141,6 @@ export function installDixiClaudeMd(projectDir, family) {
         fs.writeFileSync(claudeMdPath, templateContent, { encoding: 'utf-8' });
     }
 }
-const PSTLD_COMMANDS_SRC = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'pscode', 'content', 'dixi', 'claude-runtime', 'commands');
-const PSTLD_SKILLS_SRC = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'pscode', 'content', 'dixi', 'claude-runtime', 'skills');
 const HOOKS_SRC = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'pscode', 'content', 'dixi', 'claude-runtime', 'hooks');
 const DIXI_HOOK_ENTRIES = [
     { event: 'PreToolUse', matcher: 'Edit|Write', command: 'node .claude/hooks/arch-guard.mjs' },
@@ -296,6 +294,18 @@ export function installEslintArchitectureTemplate(projectRoot) {
         '    import architectureRules from \'./eslint-architecture.mjs\';\n' +
         '    export default [...existingConfig, ...architectureRules];\n');
 }
+export function copyDixiCommands(destRoot, srcDir, subdir) {
+    if (!fs.existsSync(srcDir))
+        return;
+    const destDir = path.join(destRoot, '.claude', 'commands', subdir);
+    if (!fs.existsSync(destDir)) {
+        fs.mkdirSync(destDir, { recursive: true });
+    }
+    const files = fs.readdirSync(srcDir);
+    for (const file of files) {
+        fs.copyFileSync(path.join(srcDir, file), path.join(destDir, file));
+    }
+}
 export function installDixiExtras(projectDir, stack) {
     const family = getDixiStackFamily(stack);
     // Resolve package content root: dist/core/presets/ → package root → pscode/content/dixi/
@@ -362,29 +372,6 @@ export function installDixiExtras(projectDir, stack) {
     else {
         console.log('[dixi] skeleton arquitetural: stack não reconhecida — skeleton não disponível para esta stack');
     }
-    // Copy /pstld:* slash commands to .claude/commands/pstld/ (idempotent — overwrites)
-    const pstldCommandsDir = path.join(projectDir, '.claude', 'commands', 'pstld');
-    if (!fs.existsSync(pstldCommandsDir)) {
-        fs.mkdirSync(pstldCommandsDir, { recursive: true });
-    }
-    if (fs.existsSync(PSTLD_COMMANDS_SRC)) {
-        const files = fs.readdirSync(PSTLD_COMMANDS_SRC);
-        for (const file of files) {
-            fs.copyFileSync(path.join(PSTLD_COMMANDS_SRC, file), path.join(pstldCommandsDir, file));
-        }
-    }
-    // Copy pstld-* skills to .claude/skills/<name>/SKILL.md (idempotent — overwrites)
-    if (fs.existsSync(PSTLD_SKILLS_SRC)) {
-        const skillFiles = fs.readdirSync(PSTLD_SKILLS_SRC).filter(f => f.endsWith('.md'));
-        for (const file of skillFiles) {
-            const skillName = file.replace(/\.md$/, '');
-            const skillDir = path.join(projectDir, '.claude', 'skills', skillName);
-            if (!fs.existsSync(skillDir)) {
-                fs.mkdirSync(skillDir, { recursive: true });
-            }
-            fs.copyFileSync(path.join(PSTLD_SKILLS_SRC, file), path.join(skillDir, 'SKILL.md'));
-        }
-    }
     // Copy hooks to .claude/hooks/ (brownfield-safe: skip if file already exists)
     const hooksDestDir = path.join(projectDir, '.claude', 'hooks');
     if (!fs.existsSync(hooksDestDir)) {
@@ -401,5 +388,8 @@ export function installDixiExtras(projectDir, stack) {
     }
     // Merge .claude/settings.json with hook registrations (never overwrite existing config)
     mergeSettingsHooks(path.join(projectDir, '.claude', 'settings.json'));
+    // Copy Dixi-aware /ps:* overrides and exclusive /pstld:* commands (always overwrite)
+    const commandsBase = path.join(packageRoot, 'pscode', 'content', 'dixi', 'commands');
+    copyDixiCommands(projectDir, path.join(commandsBase, 'ps'), 'ps');
 }
 //# sourceMappingURL=dixi.js.map

package/dist/core/profile-sync-drift.js

@@ -21,6 +21,8 @@ export const WORKFLOW_TO_SKILL_DIR = {
     // Trello-specific workflows
     'trello-setup': 'pscode-trello-setup',
     'draft': 'pscode-trello-draft',
+    // Productivity workflows
+    'handoff': 'pscode-handoff',
     // Dixi-specific workflows
     'rfc': 'pscode-dixi-rfc',
     'design': 'pscode-dixi-design',

package/dist/core/profiles.d.ts

@@ -5,7 +5,7 @@
  * `pscode init --profile <name>` or `pscode config profile <name>`.
  * The workflow lists are fixed in code — users cannot customise them.
  */
-export declare const ALL_WORKFLOWS: readonly ["propose", "explore", "new", "continue", "apply", "ff", "complete", "bulk-archive", "verify", "onboard", "trello-setup", "draft", "rfc", "design", "tasks", "arch-check", "adr", "jira-sync", "dod"];
+export declare const ALL_WORKFLOWS: readonly ["propose", "explore", "new", "continue", "apply", "ff", "complete", "bulk-archive", "verify", "onboard", "trello-setup", "draft", "rfc", "design", "tasks", "arch-check", "adr", "jira-sync", "dod", "handoff"];
 export type WorkflowId = (typeof ALL_WORKFLOWS)[number];
 export interface ProfileDefinition {
     description: string;
@@ -14,11 +14,11 @@ export interface ProfileDefinition {
 export declare const PROFILES: {
     readonly standard: {
         readonly description: "Padrão — propose, explore, apply, complete";
-        readonly workflows: readonly ["propose", "explore", "apply", "complete", "trello-setup", "draft"];
+        readonly workflows: readonly ["propose", "explore", "apply", "complete", "trello-setup", "draft", "handoff"];
     };
     readonly dixi: {
-        readonly description: "Dixi — RFC→Design→Tasks→Apply com guardrails para Java/Spring e React/Next.js";
-        readonly workflows: readonly ["rfc", "design", "tasks", "apply", "arch-check", "adr", "jira-sync", "dod"];
+        readonly description: "Dixi — propose, explore, apply, complete com guardrails para Java/Spring e React/Next.js";
+        readonly workflows: readonly ["propose", "explore", "apply", "complete", "trello-setup", "draft", "handoff"];
     };
 };
 export type ProfileName = keyof typeof PROFILES;

package/dist/core/profiles.js

@@ -25,15 +25,16 @@ export const ALL_WORKFLOWS = [
     'adr',
     'jira-sync',
     'dod',
+    'handoff',
 ];
 export const PROFILES = {
     standard: {
         description: 'Padrão — propose, explore, apply, complete',
-        workflows: ['propose', 'explore', 'apply', 'complete', 'trello-setup', 'draft'],
+        workflows: ['propose', 'explore', 'apply', 'complete', 'trello-setup', 'draft', 'handoff'],
     },
     dixi: {
-        description: 'Dixi — RFC→Design→Tasks→Apply com guardrails para Java/Spring e React/Next.js',
-        workflows: ['rfc', 'design', 'tasks', 'apply', 'arch-check', 'adr', 'jira-sync', 'dod'],
+        description: 'Dixi — propose, explore, apply, complete com guardrails para Java/Spring e React/Next.js',
+        workflows: ['propose', 'explore', 'apply', 'complete', 'trello-setup', 'draft', 'handoff'],
     },
 };
 export const DEFAULT_PROFILE = 'standard';

package/dist/core/project-config.d.ts

@@ -1,4 +1,20 @@
 import { z } from 'zod';
+export declare const PrConfigSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    branch: z.ZodOptional<z.ZodObject<{
+        pattern: z.ZodString;
+    }, z.core.$strip>>;
+    title: z.ZodOptional<z.ZodObject<{
+        template: z.ZodString;
+    }, z.core.$strip>>;
+    description: z.ZodOptional<z.ZodObject<{
+        template: z.ZodString;
+    }, z.core.$strip>>;
+    comments: z.ZodOptional<z.ZodObject<{
+        linkInTask: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PrConfig = z.infer<typeof PrConfigSchema>;
 /**
  * Zod schema for project configuration.
  *
@@ -16,6 +32,21 @@ export declare const ProjectConfigSchema: z.ZodObject<{
     schema: z.ZodString;
     context: z.ZodOptional<z.ZodString>;
     rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+    pr: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        branch: z.ZodOptional<z.ZodObject<{
+            pattern: z.ZodString;
+        }, z.core.$strip>>;
+        title: z.ZodOptional<z.ZodObject<{
+            template: z.ZodString;
+        }, z.core.$strip>>;
+        description: z.ZodOptional<z.ZodObject<{
+            template: z.ZodString;
+        }, z.core.$strip>>;
+        comments: z.ZodOptional<z.ZodObject<{
+            linkInTask: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type ProjectConfig = z.infer<typeof ProjectConfigSchema>;
 /**

package/dist/core/project-config.js

@@ -2,6 +2,13 @@ import { existsSync, readFileSync } from 'fs';
 import path from 'path';
 import { parse as parseYaml } from 'yaml';
 import { z } from 'zod';
+export const PrConfigSchema = z.object({
+    enabled: z.boolean(),
+    branch: z.object({ pattern: z.string() }).optional(),
+    title: z.object({ template: z.string() }).optional(),
+    description: z.object({ template: z.string() }).optional(),
+    comments: z.object({ linkInTask: z.boolean() }).optional(),
+});
 /**
  * Zod schema for project configuration.
  *
@@ -34,6 +41,8 @@ export const ProjectConfigSchema = z.object({
     )
         .optional()
         .describe('Per-artifact rules, keyed by artifact ID'),
+    // Optional: PR workflow configuration
+    pr: PrConfigSchema.optional().describe('PR workflow configuration'),
 });
 const MAX_CONTEXT_SIZE = 50 * 1024; // 50KB hard limit
 /**
@@ -99,6 +108,21 @@ export function readProjectConfig(projectRoot) {
                 console.warn(`Invalid 'context' field in config (must be string)`);
             }
         }
+        // Parse pr field using Zod safeParse
+        if (raw.pr !== undefined) {
+            if (typeof raw.pr === 'object' && raw.pr !== null) {
+                const prResult = PrConfigSchema.safeParse(raw.pr);
+                if (prResult.success) {
+                    config.pr = prResult.data;
+                }
+                else {
+                    console.warn(`Invalid 'pr' field in config: ${prResult.error.issues.map((i) => i.message).join(', ')}`);
+                }
+            }
+            else {
+                console.warn(`Invalid 'pr' field in config (must be object)`);
+            }
+        }
         // Parse rules field using Zod
         if (raw.rules !== undefined) {
             const rulesField = z.record(z.string(), z.array(z.string()));

package/dist/core/shared/skill-generation.js

@@ -3,7 +3,7 @@
  *
  * Shared utilities for generating skill and command files.
  */
-import { getExploreSkillTemplate, getNewChangeSkillTemplate, getContinueChangeSkillTemplate, getApplyChangeSkillTemplate, getFfChangeSkillTemplate, getCompleteChangeSkillTemplate, getBulkArchiveChangeSkillTemplate, getVerifyChangeSkillTemplate, getOnboardSkillTemplate, getProposeSkillTemplate, getTrelloSetupSkillTemplate, getTrelloDraftSkillTemplate, getPsExploreCommandTemplate, getPsNewCommandTemplate, getPsContinueCommandTemplate, getPsApplyCommandTemplate, getPsFfCommandTemplate, getPsCompleteCommandTemplate, getPsBulkArchiveCommandTemplate, getPsVerifyCommandTemplate, getPsOnboardCommandTemplate, getPsProposeCommandTemplate, getTrelloSetupCommandTemplate, getTrelloDraftCommandTemplate, } from '../templates/skill-templates.js';
+import { getExploreSkillTemplate, getNewChangeSkillTemplate, getContinueChangeSkillTemplate, getApplyChangeSkillTemplate, getFfChangeSkillTemplate, getCompleteChangeSkillTemplate, getBulkArchiveChangeSkillTemplate, getVerifyChangeSkillTemplate, getOnboardSkillTemplate, getProposeSkillTemplate, getTrelloSetupSkillTemplate, getTrelloDraftSkillTemplate, getHandoffSkillTemplate, getPsExploreCommandTemplate, getPsNewCommandTemplate, getPsContinueCommandTemplate, getPsApplyCommandTemplate, getPsFfCommandTemplate, getPsCompleteCommandTemplate, getPsBulkArchiveCommandTemplate, getPsVerifyCommandTemplate, getPsOnboardCommandTemplate, getPsProposeCommandTemplate, getTrelloSetupCommandTemplate, getTrelloDraftCommandTemplate, getHandoffCommandTemplate, } from '../templates/skill-templates.js';
 /**
  * Gets skill templates with their directory names, optionally filtered by workflow IDs.
  *
@@ -24,6 +24,8 @@ export function getSkillTemplates(workflowFilter) {
         // Trello-specific workflows
         { template: getTrelloSetupSkillTemplate(), dirName: 'pscode-trello-setup', workflowId: 'trello-setup' },
         { template: getTrelloDraftSkillTemplate(), dirName: 'pscode-trello-draft', workflowId: 'draft' },
+        // Productivity workflows
+        { template: getHandoffSkillTemplate(), dirName: 'pscode-handoff', workflowId: 'handoff' },
     ];
     if (!workflowFilter)
         return all;
@@ -50,6 +52,8 @@ export function getCommandTemplates(workflowFilter) {
         // Trello-specific workflows
         { template: getTrelloSetupCommandTemplate(), id: 'trello-setup' },
         { template: getTrelloDraftCommandTemplate(), id: 'draft' },
+        // Productivity workflows
+        { template: getHandoffCommandTemplate(), id: 'handoff' },
     ];
     if (!workflowFilter)
         return all;
@@ -86,7 +90,6 @@ export function generateSkillContent(template, generatedByVersion, transformInst
     return `---
 name: ${template.name}
 description: ${template.description}
-license: ${template.license || 'MIT'}
 compatibility: ${template.compatibility || 'Requires pscode CLI.'}
 metadata:
   author: ${template.metadata?.author || 'pscode'}

package/dist/core/templates/skill-templates.d.ts

@@ -17,4 +17,5 @@ export { getProposeSkillTemplate, getPsProposeCommandTemplate } from './workflow
 export { getFeedbackSkillTemplate } from './workflows/feedback.js';
 export { getTrelloSetupSkillTemplate, getTrelloSetupCommandTemplate } from './workflows/trello-setup.js';
 export { getTrelloDraftSkillTemplate, getTrelloDraftCommandTemplate } from './workflows/trello-draft.js';
+export { getHandoffSkillTemplate, getHandoffCommandTemplate } from './workflows/handoff.js';
 //# sourceMappingURL=skill-templates.d.ts.map

package/dist/core/templates/skill-templates.js

@@ -17,4 +17,6 @@ export { getFeedbackSkillTemplate } from './workflows/feedback.js';
 // Trello-specific workflows
 export { getTrelloSetupSkillTemplate, getTrelloSetupCommandTemplate } from './workflows/trello-setup.js';
 export { getTrelloDraftSkillTemplate, getTrelloDraftCommandTemplate } from './workflows/trello-draft.js';
+// Productivity workflows
+export { getHandoffSkillTemplate, getHandoffCommandTemplate } from './workflows/handoff.js';
 //# sourceMappingURL=skill-templates.js.map

package/dist/core/templates/types.d.ts

@@ -5,7 +5,6 @@ export interface SkillTemplate {
     name: string;
     description: string;
     instructions: string;
-    license?: string;
     compatibility?: string;
     metadata?: Record<string, string>;
 }