devflow-kit 1.1.0 → 1.3.0

package/CHANGELOG.md

@@ -5,12 +5,78 @@ All notable changes to DevFlow will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.3.0] - 2026-03-08
+
+### Added
+- **Skill shadowing** — `devflow skills shadow <name>` copies a skill for personal overrides
+  - `devflow skills unshadow <name>` restores the original
+  - `devflow skills list-shadowed` shows active overrides
+  - Shadowed skills are preserved during `devflow init` (not overwritten)
+  - Uninstall warns about remaining shadow files
+- **Cross-platform hook wrapper** — `run-hook` polyglot entry point for Windows compatibility
+  - Discovers bash on Windows (Git Bash, WSL, MSYS2) via standard paths
+  - All hook scripts renamed to drop `.sh` extension
+- **Ambient skill injection at session start** — `session-start-memory` hook injects `ambient-router` SKILL.md directly into context
+  - Eliminates the need for a Read tool call to load the ambient router
+  - Only activates when ambient mode is enabled
+- **Skill activation integration tests** — `vitest.integration.config.ts` + helpers for live classification tests
+  - Separate `npm run test:integration` for tests requiring `claude` CLI
+
+### Changed
+- **Ambient depth labels renamed** — STANDARD→GUIDED, ESCALATE→ELEVATE for clarity
+  - GUIDED: skills guide the response; ELEVATE: elevate to a full workflow
+- **Hook commands use `run-hook` dispatch** — Settings template and CLI now register hooks via `run-hook <name>` instead of direct `.sh` paths
+- **`devflow init` auto-upgrades hook format** — Removes old `.sh`-style hooks before re-adding, ensuring existing installs migrate seamlessly
+- **Skill descriptions audited** — All 12 review-only skills updated to trigger-format (`"This skill should be used when..."`)
+- **Skills architecture docs** — Added description rules section with good/bad examples
+- **`chmod` skipped on Windows** — `chmodRecursive` no longer runs on `win32` platform
+
+### Fixed
+- **Ambient preamble missing skill path** — Hook now tells Claude to `Read` skills from `~/.claude/skills/<name>/SKILL.md`
+- **Ambient `--status` hook path parsing** — Handles `run-hook <name>` format instead of assuming direct `.sh` path
+
+---
+
+## [1.2.0] - 2026-03-05
+
+### Added
+- **Polyglot language skills** — Go, Java, Python, and Rust skill plugins with comprehensive patterns
+  - Go: error handling, interfaces, concurrency (errgroup, worker pools, fan-out/fan-in)
+  - Java: records, sealed classes, streams, composition over inheritance
+  - Python: type hints, protocols, dataclasses, async patterns
+  - Rust: ownership, error handling (`thiserror`/`anyhow`), type system, concurrency
+  - Skills: 26 → 30, Plugins: 9 → 17
+- **Optional plugin architecture** — Language/ecosystem plugins (`optional: true`) not installed by default
+  - Install selectively: `devflow init --plugin=go --plugin=python`
+  - Existing skills (typescript, react, accessibility, frontend-design) moved to optional plugins
+  - `devflow-core-skills` no longer bundles language-specific skills
+- **Conditional language reviews** in `/code-review` command
+  - Spawns language-specific Reviewer agents when matching files are in the diff
+  - Skill availability check: skips review if optional plugin not installed
+- **Dynamic skill loading in Coder agent** — Reads language skills at runtime based on DOMAIN hint instead of static frontmatter dependencies
+
+### Changed
+- **`devflow-core-skills`** no longer includes typescript, react, accessibility, or frontend-design skills (moved to optional plugins)
+- **Coder agent** frontmatter trimmed from 14 skills to 6 core skills; language skills loaded dynamically
+
+### Fixed
+- **Deprecated `grpc.WithInsecure()`** in Go concurrency examples → replaced with `grpc.WithTransportCredentials(insecure.NewCredentials())`
+- **Deprecated `datetime.utcnow`** in Python dataclass example → replaced with `datetime.now(timezone.utc)`
+- **SQL injection** in Python async streaming example → replaced raw query with parameterized query
+- **Deprecated `<Context.Provider>`** in React examples → replaced with `<Context>` (React 19+)
+- **Deprecated `useRef<T>()`** without argument in React patterns → replaced with `useRef<T | undefined>(undefined)` (React 19+)
+- **Non-portable `NodeJS.Timeout`** in TypeScript debounce/throttle → replaced with `ReturnType<typeof setTimeout>`
+- **Unsafe `Function` type** in TypeScript type guard → replaced with `(...args: unknown[]) => unknown`
+- **Go test file exclusion** removed from go skill activation (test files are valid Go code)
+
+---
+
 ## [1.1.0] - 2026-03-04
 
 ### Added
 - **Ambient mode** — New `devflow-ambient` plugin with `/ambient` command for proportional quality enforcement
   - Intent classification (BUILD/DEBUG/REVIEW/PLAN/EXPLORE/CHAT) auto-loads relevant skills
-  - Three depth tiers: QUICK (zero overhead), STANDARD (2-3 skills), ESCALATE (nudge to workflows)
+  - Three depth tiers: QUICK (zero overhead), GUIDED (2-3 skills), ELEVATE (nudge to workflows)
   - Always-on mode via `devflow ambient --enable` or `devflow init --ambient`
   - New `ambient-router` skill for intent/depth classification
   - New `test-driven-development` skill (auto-activates for BUILD tasks)
@@ -749,6 +815,8 @@ devflow init
 
 ---
 
+[1.3.0]: https://github.com/dean0x/devflow/compare/v1.2.0...v1.3.0
+[1.2.0]: https://github.com/dean0x/devflow/compare/v1.1.0...v1.2.0
 [1.1.0]: https://github.com/dean0x/devflow/compare/v1.0.0...v1.1.0
 [1.0.0]: https://github.com/dean0x/devflow/compare/v0.9.0...v1.0.0
 [0.9.0]: https://github.com/dean0x/devflow/releases/tag/v0.9.0

package/README.md

@@ -24,7 +24,7 @@ DevFlow adds structured commands that handle the full lifecycle: specify feature
 - **Full-lifecycle implementation** — spec, explore, plan, code, validate, refine in one command
 - **Automatic session memory** — survives restarts, `/clear`, and context compaction
 - **Parallel debugging** — competing hypotheses investigated simultaneously
-- **26 quality skills** — 12 auto-activating, plus specialized review and agent skills
+- **30 quality skills** — 8 auto-activating core, 8 optional language/ecosystem, plus specialized review and agent skills
 
 ## Quick Start
 
@@ -81,7 +81,7 @@ Creates a PR when complete.
 Multi-perspective code review with specialized reviewers:
 
 - **Core**: Security, Architecture, Performance, Quality
-- **Conditional** (activated when relevant): TypeScript, React, Accessibility, Database, Dependencies, Documentation
+- **Conditional** (activated when relevant): TypeScript, React, Accessibility, Go, Python, Java, Rust, Database, Dependencies, Documentation
 - Findings classified as must-fix, should-fix, or nit with severity and confidence levels
 
 Provides actionable feedback with specific file locations and suggested fixes.
@@ -120,10 +120,27 @@ The `devflow-core-skills` plugin provides quality enforcement skills that activa
 | `test-driven-development` | Implementing new features (RED-GREEN-REFACTOR) |
 | `test-patterns` | Writing or modifying tests |
 | `input-validation` | Creating API endpoints |
-| `typescript` | Working in TypeScript codebases |
-| `react` | Working with React components |
-| `accessibility` | Creating UI components, forms, interactive elements |
-| `frontend-design` | Working with CSS, styling, visual design |
+
+## Language & Ecosystem Plugins
+
+Optional plugins for language-specific patterns. Install only what you need:
+
+| Plugin | Skill | Triggers When |
+|--------|-------|---------------|
+| `devflow-typescript` | `typescript` | Working in TypeScript codebases |
+| `devflow-react` | `react` | Working with React components |
+| `devflow-accessibility` | `accessibility` | Creating UI components, forms |
+| `devflow-frontend-design` | `frontend-design` | Working with CSS, styling |
+| `devflow-go` | `go` | Working in Go codebases |
+| `devflow-python` | `python` | Working in Python codebases |
+| `devflow-java` | `java` | Working in Java codebases |
+| `devflow-rust` | `rust` | Working in Rust codebases |
+
+```bash
+# Install specific language plugins
+npx devflow-kit init --plugin=typescript,react
+npx devflow-kit init --plugin=go
+```
 
 ## Requirements
 

package/dist/cli.js

@@ -8,6 +8,7 @@ import { uninstallCommand } from './commands/uninstall.js';
 import { listCommand } from './commands/list.js';
 import { ambientCommand } from './commands/ambient.js';
 import { memoryCommand } from './commands/memory.js';
+import { skillsCommand } from './commands/skills.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // Read version from package.json
@@ -25,6 +26,7 @@ program.addCommand(uninstallCommand);
 program.addCommand(listCommand);
 program.addCommand(ambientCommand);
 program.addCommand(memoryCommand);
+program.addCommand(skillsCommand);
 // Handle no command
 program.action(() => {
     program.help();

package/dist/commands/ambient.js

@@ -4,7 +4,7 @@ import * as path from 'path';
 import * as p from '@clack/prompts';
 import color from 'picocolors';
 import { getClaudeDirectory } from '../utils/paths.js';
-const AMBIENT_HOOK_MARKER = 'ambient-prompt.sh';
+const AMBIENT_HOOK_MARKER = 'ambient-prompt';
 /**
  * Add the ambient UserPromptSubmit hook to settings JSON.
  * Idempotent — returns unchanged JSON if hook already exists.
@@ -17,7 +17,7 @@ export function addAmbientHook(settingsJson, devflowDir) {
     if (!settings.hooks) {
         settings.hooks = {};
     }
-    const hookCommand = path.join(devflowDir, 'scripts', 'hooks', AMBIENT_HOOK_MARKER);
+    const hookCommand = path.join(devflowDir, 'scripts', 'hooks', 'run-hook') + ' ambient-prompt';
     const newEntry = {
         hooks: [
             {
@@ -103,8 +103,9 @@ export const ambientCommand = new Command('ambient')
         // Try to extract devflowDir from existing hooks (e.g., Stop hook path)
         const stopHook = settings.hooks?.Stop?.[0]?.hooks?.[0]?.command;
         if (stopHook) {
-            // e.g., /Users/dean/.devflow/scripts/hooks/stop-update-memory.sh → /Users/dean/.devflow
-            devflowDir = path.resolve(stopHook, '..', '..', '..');
+            // e.g., "run-hook stop-update-memory" or "/path/to/.devflow/scripts/hooks/run-hook stop-update-memory"
+            const hookBinary = stopHook.split(' ')[0];
+            devflowDir = path.resolve(hookBinary, '..', '..', '..');
         }
         else {
             devflowDir = path.join(process.env.HOME || '~', '.devflow');

package/dist/commands/init.js

@@ -379,9 +379,11 @@ export const initCommand = new Command('init')
         const settingsPath = path.join(claudeDir, 'settings.json');
         try {
             const content = await fs.readFile(settingsPath, 'utf-8');
+            // Always remove-then-add to upgrade hook format (e.g., .sh → run-hook)
+            const cleaned = removeMemoryHooks(content);
             const updated = memoryEnabled
-                ? addMemoryHooks(content, devflowDir)
-                : removeMemoryHooks(content);
+                ? addMemoryHooks(cleaned, devflowDir)
+                : cleaned;
             if (updated !== content) {
                 await fs.writeFile(settingsPath, updated, 'utf-8');
                 if (verbose) {

package/dist/commands/memory.js

@@ -9,9 +9,9 @@ import { createMemoryDir, migrateMemoryFiles } from '../utils/post-install.js';
  * Map of hook event type → filename marker for the 3 memory hooks.
  */
 const MEMORY_HOOK_CONFIG = {
-    Stop: 'stop-update-memory.sh',
-    SessionStart: 'session-start-memory.sh',
-    PreCompact: 'pre-compact-memory.sh',
+    Stop: 'stop-update-memory',
+    SessionStart: 'session-start-memory',
+    PreCompact: 'pre-compact-memory',
 };
 /**
  * Add all 3 memory hooks (Stop, SessionStart, PreCompact) to settings JSON.
@@ -30,7 +30,7 @@ export function addMemoryHooks(settingsJson, devflowDir) {
         const existing = settings.hooks[hookType] ?? [];
         const alreadyPresent = existing.some((matcher) => matcher.hooks.some((h) => h.command.includes(marker)));
         if (!alreadyPresent) {
-            const hookCommand = path.join(devflowDir, 'scripts', 'hooks', marker);
+            const hookCommand = path.join(devflowDir, 'scripts', 'hooks', 'run-hook') + ` ${marker}`;
             const newEntry = {
                 hooks: [
                     {

package/dist/commands/skills.d.ts

@@ -0,0 +1,11 @@
+import { Command } from 'commander';
+/**
+ * Check if a skill has a shadow (personal override).
+ */
+export declare function hasShadow(skillName: string, devflowDir?: string): Promise<boolean>;
+/**
+ * List all shadowed skill names.
+ */
+export declare function listShadowed(devflowDir?: string): Promise<string[]>;
+export declare const skillsCommand: Command;
+//# sourceMappingURL=skills.d.ts.map

package/dist/commands/skills.js

@@ -0,0 +1,116 @@
+import { Command } from 'commander';
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import * as p from '@clack/prompts';
+import color from 'picocolors';
+import { getClaudeDirectory, getDevFlowDirectory } from '../utils/paths.js';
+import { getAllSkillNames } from '../plugins.js';
+import { copyDirectory } from '../utils/installer.js';
+/**
+ * Check if a directory exists.
+ */
+async function dirExists(dirPath) {
+    try {
+        const stat = await fs.stat(dirPath);
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get the shadow directory for a skill.
+ */
+function getShadowDir(devflowDir, skillName) {
+    return path.join(devflowDir, 'skills', skillName);
+}
+/**
+ * Check if a skill has a shadow (personal override).
+ */
+export async function hasShadow(skillName, devflowDir) {
+    const dir = devflowDir ?? getDevFlowDirectory();
+    return dirExists(getShadowDir(dir, skillName));
+}
+/**
+ * List all shadowed skill names.
+ */
+export async function listShadowed(devflowDir) {
+    const dir = devflowDir ?? getDevFlowDirectory();
+    const shadowsRoot = path.join(dir, 'skills');
+    try {
+        const entries = await fs.readdir(shadowsRoot, { withFileTypes: true });
+        return entries.filter(e => e.isDirectory()).map(e => e.name);
+    }
+    catch {
+        return [];
+    }
+}
+export const skillsCommand = new Command('skills')
+    .description('Manage skill overrides (shadow/unshadow/list)')
+    .argument('<action>', 'Action: shadow, unshadow, or list-shadowed')
+    .argument('[name]', 'Skill name (required for shadow/unshadow)')
+    .action(async (action, name) => {
+    const devflowDir = getDevFlowDirectory();
+    const claudeDir = getClaudeDirectory();
+    const allSkills = getAllSkillNames();
+    if (action === 'shadow') {
+        if (!name) {
+            p.log.error('Skill name required. Usage: devflow skills shadow <name>');
+            p.log.info(`Available skills: ${allSkills.join(', ')}`);
+            process.exit(1);
+        }
+        if (!allSkills.includes(name)) {
+            p.log.error(`Unknown skill: ${name}`);
+            p.log.info(`Available skills: ${allSkills.join(', ')}`);
+            process.exit(1);
+        }
+        const installedSkillDir = path.join(claudeDir, 'skills', name);
+        if (!await dirExists(installedSkillDir)) {
+            p.log.error(`Skill not installed: ${name}. Run devflow init first.`);
+            process.exit(1);
+        }
+        const shadowDir = getShadowDir(devflowDir, name);
+        if (await dirExists(shadowDir)) {
+            p.log.info(`${name} is already shadowed`);
+            return;
+        }
+        // Create shadow directory and copy original as reference backup
+        await fs.mkdir(path.join(devflowDir, 'skills'), { recursive: true });
+        await copyDirectory(installedSkillDir, shadowDir);
+        p.log.success(`Shadowed ${color.cyan(name)}`);
+        p.log.info(`Edit ${color.dim(path.join(claudeDir, 'skills', name, 'SKILL.md'))} — it won't be overwritten on next init.`);
+    }
+    else if (action === 'unshadow') {
+        if (!name) {
+            p.log.error('Skill name required. Usage: devflow skills unshadow <name>');
+            process.exit(1);
+        }
+        const shadowDir = getShadowDir(devflowDir, name);
+        if (!await dirExists(shadowDir)) {
+            p.log.info(`${name} is not shadowed`);
+            return;
+        }
+        await fs.rm(shadowDir, { recursive: true, force: true });
+        p.log.success(`Unshadowed ${color.cyan(name)}`);
+        p.log.info('Run devflow init to restore DevFlow\'s version.');
+    }
+    else if (action === 'list-shadowed') {
+        const shadowed = await listShadowed(devflowDir);
+        if (shadowed.length === 0) {
+            p.log.info('No shadowed skills');
+            return;
+        }
+        p.log.info(`Shadowed skills (${shadowed.length}):`);
+        for (const skill of shadowed) {
+            const isKnown = allSkills.includes(skill);
+            const status = isKnown ? color.green('active') : color.yellow('unknown skill');
+            p.log.info(`  ${color.cyan(skill)} — ${status}`);
+        }
+    }
+    else {
+        p.log.error(`Unknown action: ${action}`);
+        p.log.info('Usage: devflow skills <shadow|unshadow|list-shadowed> [name]');
+        process.exit(1);
+    }
+});
+//# sourceMappingURL=skills.js.map

package/dist/commands/uninstall.js

@@ -5,12 +5,13 @@ import { fileURLToPath } from 'url';
 import { execSync } from 'child_process';
 import * as p from '@clack/prompts';
 import color from 'picocolors';
-import { getInstallationPaths, getClaudeDirectory, getManagedSettingsPath } from '../utils/paths.js';
+import { getInstallationPaths, getClaudeDirectory, getDevFlowDirectory, getManagedSettingsPath } from '../utils/paths.js';
 import { getGitRoot } from '../utils/git.js';
 import { isClaudeCliAvailable } from '../utils/cli.js';
 import { DEVFLOW_PLUGINS, getAllSkillNames, LEGACY_SKILL_NAMES } from '../plugins.js';
 import { removeAmbientHook } from './ambient.js';
 import { removeMemoryHooks } from './memory.js';
+import { listShadowed } from './skills.js';
 import { detectShell, getProfilePath } from '../utils/safe-delete.js';
 import { isAlreadyInstalled, removeFromProfile } from '../utils/safe-delete-install.js';
 import { removeManagedSettings } from '../utils/post-install.js';
@@ -403,6 +404,15 @@ export const uninstallCommand = new Command('uninstall')
             }
         }
     }
+    // Warn about personal skill overrides
+    if (!isSelectiveUninstall) {
+        const shadowed = await listShadowed();
+        if (shadowed.length > 0) {
+            const shadowPath = path.join(getDevFlowDirectory(), 'skills');
+            p.log.warn(`Personal skill overrides remain in ${shadowPath}: ${shadowed.join(', ')}`);
+            p.log.info(color.dim(`Remove manually or run: rm -rf ${shadowPath}`));
+        }
+    }
     const status = color.green('DevFlow uninstalled successfully');
     p.outro(`${status}${color.dim('  Reinstall: npx devflow-kit init')}`);
 });

package/dist/plugins.js

@@ -10,7 +10,7 @@ export const DEVFLOW_PLUGINS = [
         description: 'Auto-activating quality enforcement (foundation layer)',
         commands: [],
         agents: [],
-        skills: ['accessibility', 'core-patterns', 'docs-framework', 'frontend-design', 'git-safety', 'git-workflow', 'github-patterns', 'input-validation', 'react', 'test-driven-development', 'test-patterns', 'typescript'],
+        skills: ['core-patterns', 'docs-framework', 'git-safety', 'git-workflow', 'github-patterns', 'input-validation', 'test-driven-development', 'test-patterns'],
     },
     {
         name: 'devflow-specify',
@@ -24,14 +24,14 @@ export const DEVFLOW_PLUGINS = [
         description: 'Complete task implementation workflow',
         commands: ['/implement'],
         agents: ['git', 'skimmer', 'synthesizer', 'coder', 'simplifier', 'scrutinizer', 'shepherd', 'validator'],
-        skills: ['accessibility', 'agent-teams', 'frontend-design', 'implementation-patterns', 'self-review'],
+        skills: ['agent-teams', 'implementation-patterns', 'self-review'],
     },
     {
         name: 'devflow-code-review',
         description: 'Comprehensive code review',
         commands: ['/code-review'],
         agents: ['git', 'reviewer', 'synthesizer'],
-        skills: ['accessibility', 'agent-teams', 'architecture-patterns', 'complexity-patterns', 'consistency-patterns', 'database-patterns', 'dependencies-patterns', 'documentation-patterns', 'frontend-design', 'performance-patterns', 'react', 'regression-patterns', 'review-methodology', 'security-patterns', 'test-patterns'],
+        skills: ['agent-teams', 'architecture-patterns', 'complexity-patterns', 'consistency-patterns', 'database-patterns', 'dependencies-patterns', 'documentation-patterns', 'performance-patterns', 'regression-patterns', 'review-methodology', 'security-patterns', 'test-patterns'],
     },
     {
         name: 'devflow-resolve',
@@ -69,6 +69,70 @@ export const DEVFLOW_PLUGINS = [
         skills: [],
         optional: true,
     },
+    {
+        name: 'devflow-typescript',
+        description: 'TypeScript language patterns (type safety, generics, utility types)',
+        commands: [],
+        agents: [],
+        skills: ['typescript'],
+        optional: true,
+    },
+    {
+        name: 'devflow-react',
+        description: 'React framework patterns (hooks, state, composition, performance)',
+        commands: [],
+        agents: [],
+        skills: ['react'],
+        optional: true,
+    },
+    {
+        name: 'devflow-accessibility',
+        description: 'Web accessibility patterns (WCAG, ARIA, keyboard navigation)',
+        commands: [],
+        agents: [],
+        skills: ['accessibility'],
+        optional: true,
+    },
+    {
+        name: 'devflow-frontend-design',
+        description: 'Frontend design patterns (typography, color, spacing, motion)',
+        commands: [],
+        agents: [],
+        skills: ['frontend-design'],
+        optional: true,
+    },
+    {
+        name: 'devflow-go',
+        description: 'Go language patterns (error handling, interfaces, concurrency)',
+        commands: [],
+        agents: [],
+        skills: ['go'],
+        optional: true,
+    },
+    {
+        name: 'devflow-java',
+        description: 'Java language patterns (records, sealed classes, composition)',
+        commands: [],
+        agents: [],
+        skills: ['java'],
+        optional: true,
+    },
+    {
+        name: 'devflow-python',
+        description: 'Python language patterns (type hints, protocols, data modeling)',
+        commands: [],
+        agents: [],
+        skills: ['python'],
+        optional: true,
+    },
+    {
+        name: 'devflow-rust',
+        description: 'Rust language patterns (ownership, error handling, type system)',
+        commands: [],
+        agents: [],
+        skills: ['rust'],
+        optional: true,
+    },
 ];
 /**
  * Deprecated command names from old installations.

package/dist/utils/installer.js

@@ -105,6 +105,14 @@ export async function installViaFileCopy(options) {
             }
         }
         for (const skill of allSkills) {
+            // Skip cleanup for shadowed skills — user has a personal override
+            const shadowDir = path.join(devflowDir, 'skills', skill);
+            try {
+                const stat = await fs.stat(shadowDir);
+                if (stat.isDirectory())
+                    continue;
+            }
+            catch { /* no shadow — proceed with cleanup */ }
             try {
                 await fs.rm(path.join(claudeDir, 'skills', skill), { recursive: true, force: true });
             }
@@ -148,13 +156,21 @@ export async function installViaFileCopy(options) {
             }
         }
         catch { /* no agents directory */ }
-        // Install skills (deduplicated)
+        // Install skills (deduplicated, respects shadows)
         const skillsSource = path.join(pluginSourceDir, 'skills');
         try {
             const skillDirs = await fs.readdir(skillsSource, { withFileTypes: true });
             for (const skillDir of skillDirs) {
                 if (skillDir.isDirectory()) {
                     if (skillsMap.get(skillDir.name) === plugin.name) {
+                        // Skip copy for shadowed skills — user has a personal override
+                        const shadowDir = path.join(devflowDir, 'skills', skillDir.name);
+                        try {
+                            const stat = await fs.stat(shadowDir);
+                            if (stat.isDirectory())
+                                continue;
+                        }
+                        catch { /* no shadow — proceed with copy */ }
                         const skillTarget = path.join(claudeDir, 'skills', skillDir.name);
                         await copyDirectory(path.join(skillsSource, skillDir.name), skillTarget);
                     }
@@ -169,7 +185,9 @@ export async function installViaFileCopy(options) {
     try {
         await fs.mkdir(scriptsTarget, { recursive: true });
         await copyDirectory(scriptsSource, scriptsTarget);
-        await chmodRecursive(scriptsTarget, 0o755);
+        if (process.platform !== 'win32') {
+            await chmodRecursive(scriptsTarget, 0o755);
+        }
     }
     catch { /* scripts may not exist */ }
     spinner.stop('Components installed via file copy');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devflow-kit",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Agentic Development Toolkit for Claude Code - Enhance AI-assisted development with intelligent commands and workflows",
   "type": "module",
   "bin": {
@@ -24,8 +24,10 @@
     "dev": "tsc --watch",
     "cli": "node dist/cli.js",
     "prepublishOnly": "npm run build",
+    "version:bump": "npx tsx scripts/bump-version.ts",
     "test": "vitest run",
-    "test:watch": "vitest"
+    "test:watch": "vitest",
+    "test:integration": "vitest run --config vitest.integration.config.ts"
   },
   "keywords": [
     "claude",

package/plugins/devflow-accessibility/.claude-plugin/plugin.json

@@ -0,0 +1,22 @@
+{
+  "name": "devflow-accessibility",
+  "description": "Web accessibility patterns - WCAG compliance, ARIA roles, keyboard navigation, focus management",
+  "author": {
+    "name": "DevFlow Contributors",
+    "email": "dean@keren.dev"
+  },
+  "version": "1.3.0",
+  "homepage": "https://github.com/dean0x/devflow",
+  "repository": "https://github.com/dean0x/devflow",
+  "license": "MIT",
+  "keywords": [
+    "accessibility",
+    "wcag",
+    "aria",
+    "a11y"
+  ],
+  "agents": [],
+  "skills": [
+    "accessibility"
+  ]
+}

package/plugins/devflow-ambient/.claude-plugin/plugin.json

@@ -1,7 +1,9 @@
 {
   "name": "devflow-ambient",
   "description": "Ambient mode — auto-loads relevant skills for every prompt",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "agents": [],
-  "skills": ["ambient-router"]
+  "skills": [
+    "ambient-router"
+  ]
 }

package/plugins/devflow-ambient/README.md

@@ -9,10 +9,10 @@ Ambient mode — auto-loads relevant skills based on each prompt, no explicit co
 Classify user intent and apply proportional skill enforcement to any prompt.
 
 ```bash
-/ambient add a login form          # BUILD/STANDARD — loads TDD + implementation-patterns
-/ambient fix the auth error        # DEBUG/STANDARD — loads test-patterns + core-patterns
+/ambient add a login form          # BUILD/GUIDED — loads TDD + implementation-patterns
+/ambient fix the auth error        # DEBUG/GUIDED — loads test-patterns + core-patterns
 /ambient where is the config?      # EXPLORE/QUICK — responds normally, zero overhead
-/ambient refactor the auth system  # BUILD/ESCALATE — suggests /implement
+/ambient refactor the auth system  # BUILD/ELEVATE — suggests /implement
 ```
 
 ## Always-On Mode
@@ -30,19 +30,19 @@ When enabled, a `UserPromptSubmit` hook injects a classification preamble before
 ## How It Works
 
 1. **Classify intent** — BUILD, DEBUG, REVIEW, PLAN, EXPLORE, or CHAT
-2. **Classify depth** — QUICK (zero overhead), STANDARD (2-3 skills), or ESCALATE (workflow nudge)
+2. **Classify depth** — QUICK (zero overhead), GUIDED (2-3 skills), or ELEVATE (workflow nudge)
 3. **Apply proportionally**:
    - QUICK: respond normally
-   - STANDARD: load relevant skills, enforce TDD for BUILD
-   - ESCALATE: respond + recommend full workflow command
+   - GUIDED: load relevant skills, enforce TDD for BUILD
+   - ELEVATE: respond + recommend full workflow command
 
 ## Depth Tiers
 
 | Depth | When | Overhead |
 |-------|------|----------|
 | QUICK | Chat, simple exploration, git/devops ops, single-word confirmations | ~0 tokens |
-| STANDARD | BUILD/DEBUG/REVIEW/PLAN, 1-5 file scope | ~500-1000 tokens (skill reads) |
-| ESCALATE | Multi-file, architectural, system-wide scope | ~0 extra tokens (nudge only) |
+| GUIDED | BUILD/DEBUG/REVIEW/PLAN, 1-5 file scope | ~500-1000 tokens (skill reads) |
+| ELEVATE | Multi-file, architectural, system-wide scope | ~0 extra tokens (nudge only) |
 
 ## Skills