devflow-kit 1.0.0 → 1.1.0

package/CHANGELOG.md

@@ -5,6 +5,35 @@ 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.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)
+  - 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)
+  - Skills: 24 → 26, Plugins: 8 → 9
+- **Working memory enhancements** — Structured cross-session context preservation
+  - Structured sections: Now, Progress, Decisions, Modified Files, Context, Session Log
+  - Toggleable via `devflow memory --enable/--disable/--status` or `devflow init --memory/--no-memory`
+  - `PROJECT-PATTERNS.md` extraction — background hook accumulates patterns across sessions
+  - Directory separation: `.memory/` (session state) vs `.docs/` (reviews/design artifacts)
+  - Auto-migration from `.docs/` to `.memory/` with no-clobber semantics
+  - Auto-adds `.memory/` and `.docs/` to `.gitignore` on first hook run
+
+### Changed
+- **Background agent permissions** — Replaced `--dangerously-skip-permissions` with `--tools "Write"` + `--allowedTools` for restricted file access in memory update hooks
+- **Safe-delete auto-upgrade** — `devflow init` now detects outdated safe-delete blocks and silently upgrades them; no manual uninstall/reinstall needed
+
+### Fixed
+- **Ambient depth classification** — Intent now drives depth exclusively; removed 20-word threshold that silently downgraded ~32% of BUILD/DEBUG prompts to QUICK (#73)
+- **Safe-delete file existence** — Filter non-existent files before calling `trash` in bash/zsh, fish, and PowerShell Unix blocks; prevents noisy `trash: file doesn't exist` errors on `rm -f` of missing files (#74)
+- **Safe-delete deny list** — Expanded `rm` deny patterns from 8 to 21, covering `rm -r`, `rm -fr`, and `rm -f` flag variations that could bypass the `rm -rf`-only patterns (#74)
+
+---
+
 ## [1.0.0] - 2026-02-25
 
 ### Added
@@ -720,6 +749,7 @@ devflow init
 
 ---
 
+[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
 [0.8.1]: https://github.com/dean0x/devflow/releases/tag/v0.8.1

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
-- **24 quality skills** — 11 auto-activating, plus specialized review and agent skills
+- **26 quality skills** — 12 auto-activating, plus specialized review and agent skills
 
 ## Quick Start
 
@@ -48,6 +48,7 @@ Then in Claude Code:
 | `devflow-resolve` | `/resolve` | Process review issues — fix or defer to tech debt |
 | `devflow-debug` | `/debug` | Parallel hypothesis debugging |
 | `devflow-self-review` | `/self-review` | Self-review workflow (Simplifier + Scrutinizer) |
+| `devflow-ambient` | `/ambient` | Ambient mode — auto-loads relevant skills based on each prompt |
 | `devflow-core-skills` | (auto) | Auto-activating quality enforcement skills |
 
 ## Command Details
@@ -116,6 +117,7 @@ The `devflow-core-skills` plugin provides quality enforcement skills that activa
 | `git-safety` | Rebasing, force-pushing, merge conflicts |
 | `git-workflow` | Staging files, creating commits, PRs |
 | `github-patterns` | GitHub API operations, PR comments, releases |
+| `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 |
@@ -160,22 +162,25 @@ Three shell hooks run behind the scenes:
 
 | Hook | When | What |
 |------|------|------|
-| **Stop** | After each response | Updates `.docs/WORKING-MEMORY.md` with current focus, decisions, and progress. Throttled — skips if updated <2 min ago. |
+| **Stop** | After each response | Updates `.memory/WORKING-MEMORY.md` with current focus, decisions, and progress. Throttled — skips if updated <2 min ago. |
 | **SessionStart** | On startup, `/clear`, resume, compaction | Injects previous working memory + fresh git state as system context. Warns if memory is >1h stale. |
 | **PreCompact** | Before context compaction | Backs up git state to JSON. Bootstraps a minimal working memory from git if none exists yet. |
 
-Working memory is **per-project** — scoped to each repo's `.docs/` directory. Multiple sessions across different repos don't interfere.
+Working memory is **per-project** — scoped to each repo's `.memory/` directory. Multiple sessions across different repos don't interfere.
 
 ## Documentation Structure
 
-DevFlow creates project documentation in `.docs/`:
+DevFlow creates project documentation in `.docs/` and working memory in `.memory/`:
 
 ```
 .docs/
 ├── reviews/{branch}/         # Review reports per branch
-├── design/                   # Implementation plans
+└── design/                   # Implementation plans
+
+.memory/
 ├── WORKING-MEMORY.md         # Auto-maintained by Stop hook
-└── working-memory-backup.json # Pre-compact git state snapshot
+├── PROJECT-PATTERNS.md       # Accumulated patterns across sessions
+└── backup.json               # Pre-compact git state snapshot
 ```
 
 ## Workflow Examples
@@ -209,6 +214,8 @@ Session context is saved and restored automatically via Working Memory hooks —
 | `npx devflow-kit init` | Install all plugins |
 | `npx devflow-kit init --plugin=<names>` | Install specific plugin(s) |
 | `npx devflow-kit list` | List available plugins |
+| `npx devflow-kit ambient --enable` | Enable always-on ambient mode |
+| `npx devflow-kit ambient --disable` | Disable ambient mode |
 | `npx devflow-kit uninstall` | Remove DevFlow |
 
 ### Init Options

package/dist/cli.js

@@ -6,6 +6,8 @@ import { dirname, join } from 'path';
 import { initCommand } from './commands/init.js';
 import { uninstallCommand } from './commands/uninstall.js';
 import { listCommand } from './commands/list.js';
+import { ambientCommand } from './commands/ambient.js';
+import { memoryCommand } from './commands/memory.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // Read version from package.json
@@ -16,11 +18,13 @@ program
     .description('Agentic Development Toolkit for Claude Code\n\nEnhance your AI-assisted development with intelligent commands and workflows.')
     .version(packageJson.version, '-v, --version', 'Display version number')
     .helpOption('-h, --help', 'Display help information')
-    .addHelpText('after', '\nExamples:\n  $ devflow init                       Install all DevFlow plugins\n  $ devflow init --plugin=implement    Install specific plugin\n  $ devflow init --plugin=implement,review  Install multiple plugins\n  $ devflow list                       List available plugins\n  $ devflow uninstall                  Remove DevFlow from Claude Code\n  $ devflow --version                  Show version\n  $ devflow --help                     Show help\n\nDocumentation:\n  https://github.com/dean0x/devflow#readme');
+    .addHelpText('after', '\nExamples:\n  $ devflow init                       Install all DevFlow plugins\n  $ devflow init --plugin=implement    Install specific plugin\n  $ devflow init --plugin=implement,review  Install multiple plugins\n  $ devflow list                       List available plugins\n  $ devflow ambient --enable           Enable always-on ambient mode\n  $ devflow memory --status            Check working memory state\n  $ devflow uninstall                  Remove DevFlow from Claude Code\n  $ devflow --version                  Show version\n  $ devflow --help                     Show help\n\nDocumentation:\n  https://github.com/dean0x/devflow#readme');
 // Register commands
 program.addCommand(initCommand);
 program.addCommand(uninstallCommand);
 program.addCommand(listCommand);
+program.addCommand(ambientCommand);
+program.addCommand(memoryCommand);
 // Handle no command
 program.action(() => {
     program.help();

package/dist/commands/ambient.d.ts

@@ -0,0 +1,18 @@
+import { Command } from 'commander';
+/**
+ * Add the ambient UserPromptSubmit hook to settings JSON.
+ * Idempotent — returns unchanged JSON if hook already exists.
+ */
+export declare function addAmbientHook(settingsJson: string, devflowDir: string): string;
+/**
+ * Remove the ambient UserPromptSubmit hook from settings JSON.
+ * Idempotent — returns unchanged JSON if hook not present.
+ * Preserves other UserPromptSubmit hooks. Cleans empty arrays/objects.
+ */
+export declare function removeAmbientHook(settingsJson: string): string;
+/**
+ * Check if the ambient hook is registered in settings JSON.
+ */
+export declare function hasAmbientHook(settingsJson: string): boolean;
+export declare const ambientCommand: Command;
+//# sourceMappingURL=ambient.d.ts.map

package/dist/commands/ambient.js

@@ -0,0 +1,136 @@
+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 } from '../utils/paths.js';
+const AMBIENT_HOOK_MARKER = 'ambient-prompt.sh';
+/**
+ * Add the ambient UserPromptSubmit hook to settings JSON.
+ * Idempotent — returns unchanged JSON if hook already exists.
+ */
+export function addAmbientHook(settingsJson, devflowDir) {
+    const settings = JSON.parse(settingsJson);
+    if (hasAmbientHook(settingsJson)) {
+        return settingsJson;
+    }
+    if (!settings.hooks) {
+        settings.hooks = {};
+    }
+    const hookCommand = path.join(devflowDir, 'scripts', 'hooks', AMBIENT_HOOK_MARKER);
+    const newEntry = {
+        hooks: [
+            {
+                type: 'command',
+                command: hookCommand,
+                timeout: 5,
+            },
+        ],
+    };
+    if (!settings.hooks.UserPromptSubmit) {
+        settings.hooks.UserPromptSubmit = [];
+    }
+    settings.hooks.UserPromptSubmit.push(newEntry);
+    return JSON.stringify(settings, null, 2) + '\n';
+}
+/**
+ * Remove the ambient UserPromptSubmit hook from settings JSON.
+ * Idempotent — returns unchanged JSON if hook not present.
+ * Preserves other UserPromptSubmit hooks. Cleans empty arrays/objects.
+ */
+export function removeAmbientHook(settingsJson) {
+    const settings = JSON.parse(settingsJson);
+    if (!settings.hooks?.UserPromptSubmit) {
+        return settingsJson;
+    }
+    settings.hooks.UserPromptSubmit = settings.hooks.UserPromptSubmit.filter((matcher) => !matcher.hooks.some((h) => h.command.includes(AMBIENT_HOOK_MARKER)));
+    if (settings.hooks.UserPromptSubmit.length === 0) {
+        delete settings.hooks.UserPromptSubmit;
+    }
+    if (settings.hooks && Object.keys(settings.hooks).length === 0) {
+        delete settings.hooks;
+    }
+    return JSON.stringify(settings, null, 2) + '\n';
+}
+/**
+ * Check if the ambient hook is registered in settings JSON.
+ */
+export function hasAmbientHook(settingsJson) {
+    const settings = JSON.parse(settingsJson);
+    if (!settings.hooks?.UserPromptSubmit) {
+        return false;
+    }
+    return settings.hooks.UserPromptSubmit.some((matcher) => matcher.hooks.some((h) => h.command.includes(AMBIENT_HOOK_MARKER)));
+}
+export const ambientCommand = new Command('ambient')
+    .description('Enable or disable ambient mode (always-on quality enforcement)')
+    .option('--enable', 'Register UserPromptSubmit hook for ambient mode')
+    .option('--disable', 'Remove ambient mode hook')
+    .option('--status', 'Check if ambient mode is enabled')
+    .action(async (options) => {
+    const hasFlag = options.enable || options.disable || options.status;
+    if (!hasFlag) {
+        p.intro(color.bgMagenta(color.white(' Ambient Mode ')));
+        p.note(`${color.cyan('devflow ambient --enable')}   Register always-on hook\n` +
+            `${color.cyan('devflow ambient --disable')}  Remove always-on hook\n` +
+            `${color.cyan('devflow ambient --status')}   Check current state`, 'Usage');
+        p.outro(color.dim('Or use /ambient <prompt> for one-shot classification'));
+        return;
+    }
+    const claudeDir = getClaudeDirectory();
+    const settingsPath = path.join(claudeDir, 'settings.json');
+    let settingsContent;
+    try {
+        settingsContent = await fs.readFile(settingsPath, 'utf-8');
+    }
+    catch {
+        if (options.status) {
+            p.log.info('Ambient mode: disabled (no settings.json found)');
+            return;
+        }
+        // Create minimal settings.json
+        settingsContent = '{}';
+    }
+    if (options.status) {
+        const enabled = hasAmbientHook(settingsContent);
+        p.log.info(`Ambient mode: ${enabled ? color.green('enabled') : color.dim('disabled')}`);
+        return;
+    }
+    // Resolve devflow scripts directory from settings.json hooks or default
+    let devflowDir;
+    try {
+        const settings = JSON.parse(settingsContent);
+        // 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, '..', '..', '..');
+        }
+        else {
+            devflowDir = path.join(process.env.HOME || '~', '.devflow');
+        }
+    }
+    catch {
+        devflowDir = path.join(process.env.HOME || '~', '.devflow');
+    }
+    if (options.enable) {
+        const updated = addAmbientHook(settingsContent, devflowDir);
+        if (updated === settingsContent) {
+            p.log.info('Ambient mode already enabled');
+            return;
+        }
+        await fs.writeFile(settingsPath, updated, 'utf-8');
+        p.log.success('Ambient mode enabled — UserPromptSubmit hook registered');
+        p.log.info(color.dim('Relevant skills will now auto-load based on each prompt'));
+    }
+    if (options.disable) {
+        const updated = removeAmbientHook(settingsContent);
+        if (updated === settingsContent) {
+            p.log.info('Ambient mode already disabled');
+            return;
+        }
+        await fs.writeFile(settingsPath, updated, 'utf-8');
+        p.log.success('Ambient mode disabled — hook removed');
+    }
+});
+//# sourceMappingURL=ambient.js.map

package/dist/commands/init.d.ts

@@ -1,6 +1,8 @@
 import { Command } from 'commander';
 import { type PluginDefinition } from '../plugins.js';
 export { substituteSettingsTemplate, computeGitignoreAppend, applyTeamsConfig, stripTeamsConfig, mergeDenyList } from '../utils/post-install.js';
+export { addAmbientHook, removeAmbientHook, hasAmbientHook } from './ambient.js';
+export { addMemoryHooks, removeMemoryHooks, hasMemoryHooks } from './memory.js';
 /**
  * Parse a comma-separated plugin selection string into normalized plugin names.
  * Validates against known plugins; returns invalid names as errors.

package/dist/commands/init.js

@@ -9,12 +9,16 @@ import { getInstallationPaths } from '../utils/paths.js';
 import { getGitRoot } from '../utils/git.js';
 import { isClaudeCliAvailable } from '../utils/cli.js';
 import { installViaCli, installViaFileCopy } from '../utils/installer.js';
-import { installSettings, installManagedSettings, installClaudeignore, updateGitignore, createDocsStructure, } from '../utils/post-install.js';
+import { installSettings, installManagedSettings, installClaudeignore, updateGitignore, createDocsStructure, createMemoryDir, migrateMemoryFiles, } from '../utils/post-install.js';
 import { DEVFLOW_PLUGINS, LEGACY_SKILL_NAMES, LEGACY_COMMAND_NAMES, buildAssetMaps } from '../plugins.js';
 import { detectPlatform, detectShell, getProfilePath, getSafeDeleteInfo, hasSafeDelete } from '../utils/safe-delete.js';
-import { generateSafeDeleteBlock, isAlreadyInstalled, installToProfile } from '../utils/safe-delete-install.js';
+import { generateSafeDeleteBlock, installToProfile, removeFromProfile, getInstalledVersion, SAFE_DELETE_BLOCK_VERSION } from '../utils/safe-delete-install.js';
+import { addAmbientHook } from './ambient.js';
+import { addMemoryHooks, removeMemoryHooks } from './memory.js';
 // Re-export pure functions for tests (canonical source is post-install.ts)
 export { substituteSettingsTemplate, computeGitignoreAppend, applyTeamsConfig, stripTeamsConfig, mergeDenyList } from '../utils/post-install.js';
+export { addAmbientHook, removeAmbientHook, hasAmbientHook } from './ambient.js';
+export { addMemoryHooks, removeMemoryHooks, hasMemoryHooks } from './memory.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 /**
@@ -57,6 +61,10 @@ export const initCommand = new Command('init')
     .option('--plugin <names>', 'Install specific plugin(s), comma-separated (e.g., implement,code-review)')
     .option('--teams', 'Enable Agent Teams (peer debate, adversarial review)')
     .option('--no-teams', 'Disable Agent Teams (use parallel subagents instead)')
+    .option('--ambient', 'Enable ambient mode (auto-loads relevant skills for every prompt)')
+    .option('--no-ambient', 'Disable ambient mode')
+    .option('--memory', 'Enable working memory (session context preservation)')
+    .option('--no-memory', 'Disable working memory hooks')
     .action(async (options) => {
     // Get package version
     const packageJsonPath = path.resolve(__dirname, '../../package.json');
@@ -152,6 +160,44 @@ export const initCommand = new Command('init')
         }
         teamsEnabled = teamsChoice;
     }
+    // Ambient mode selection
+    let ambientEnabled;
+    if (options.ambient !== undefined) {
+        ambientEnabled = options.ambient;
+    }
+    else if (!process.stdin.isTTY) {
+        ambientEnabled = false;
+    }
+    else {
+        const ambientChoice = await p.confirm({
+            message: 'Enable ambient mode? (auto-loads relevant skills based on each prompt)',
+            initialValue: false,
+        });
+        if (p.isCancel(ambientChoice)) {
+            p.cancel('Installation cancelled.');
+            process.exit(0);
+        }
+        ambientEnabled = ambientChoice;
+    }
+    // Working memory selection (defaults ON — foundational, unlike ambient's false)
+    let memoryEnabled;
+    if (options.memory !== undefined) {
+        memoryEnabled = options.memory;
+    }
+    else if (!process.stdin.isTTY) {
+        memoryEnabled = true;
+    }
+    else {
+        const memoryChoice = await p.confirm({
+            message: 'Enable working memory? (automatic session context preservation)',
+            initialValue: true,
+        });
+        if (p.isCancel(memoryChoice)) {
+            p.cancel('Installation cancelled.');
+            process.exit(0);
+        }
+        memoryEnabled = memoryChoice;
+    }
     // Security deny list placement (user scope + TTY only)
     let securityMode = 'user';
     if (scope === 'user' && process.stdin.isTTY) {
@@ -314,6 +360,41 @@ export const initCommand = new Command('init')
             }
         }
         await installSettings(claudeDir, rootDir, devflowDir, verbose, teamsEnabled, effectiveSecurityMode);
+        // Install ambient hook if enabled
+        if (ambientEnabled) {
+            const settingsPath = path.join(claudeDir, 'settings.json');
+            try {
+                const content = await fs.readFile(settingsPath, 'utf-8');
+                const updated = addAmbientHook(content, devflowDir);
+                if (updated !== content) {
+                    await fs.writeFile(settingsPath, updated, 'utf-8');
+                    if (verbose) {
+                        p.log.success('Ambient mode hook installed');
+                    }
+                }
+            }
+            catch { /* settings.json may not exist yet */ }
+        }
+        // Manage memory hooks based on user choice
+        const settingsPath = path.join(claudeDir, 'settings.json');
+        try {
+            const content = await fs.readFile(settingsPath, 'utf-8');
+            const updated = memoryEnabled
+                ? addMemoryHooks(content, devflowDir)
+                : removeMemoryHooks(content);
+            if (updated !== content) {
+                await fs.writeFile(settingsPath, updated, 'utf-8');
+                if (verbose) {
+                    p.log.info(`Working memory ${memoryEnabled ? 'enabled' : 'disabled'}`);
+                }
+            }
+        }
+        catch { /* settings.json may not exist yet */ }
+        // Ensure .memory/ exists when memory is enabled (hooks are no-ops without it)
+        if (memoryEnabled) {
+            await createMemoryDir(verbose);
+            await migrateMemoryFiles(verbose);
+        }
     }
     const fileExtras = selectedExtras.filter(e => e !== 'settings' && e !== 'safe-delete');
     if (fileExtras.length > 0) {
@@ -357,14 +438,20 @@ export const initCommand = new Command('init')
                 p.log.info(`Then re-run ${color.cyan('devflow init')} to auto-configure safe-delete.`);
             }
             else if (safeDeleteAvailable) {
-                const alreadyInstalled = await isAlreadyInstalled(profilePath);
-                if (alreadyInstalled) {
-                    p.log.info(`Safe-delete already configured in ${color.dim(profilePath)}`);
-                }
-                else {
-                    const trashCmd = safeDeleteInfo.command;
-                    const block = generateSafeDeleteBlock(shell, process.platform, trashCmd);
-                    if (block) {
+                const trashCmd = safeDeleteInfo.command;
+                const block = generateSafeDeleteBlock(shell, process.platform, trashCmd);
+                if (block) {
+                    const installedVersion = await getInstalledVersion(profilePath);
+                    if (installedVersion === SAFE_DELETE_BLOCK_VERSION) {
+                        p.log.info(`Safe-delete already configured in ${color.dim(profilePath)}`);
+                    }
+                    else if (installedVersion > 0) {
+                        await removeFromProfile(profilePath);
+                        await installToProfile(profilePath, block);
+                        p.log.success(`Safe-delete upgraded in ${color.dim(profilePath)}`);
+                        p.log.info('Restart your shell or run: ' + color.cyan(`source ${profilePath}`));
+                    }
+                    else {
                         const confirm = await p.confirm({
                             message: `Install safe-delete to ${profilePath}? (overrides rm to use ${trashCmd ?? 'recycle bin'})`,
                             initialValue: true,

package/dist/commands/memory.d.ts

@@ -0,0 +1,22 @@
+import { Command } from 'commander';
+/**
+ * Add all 3 memory hooks (Stop, SessionStart, PreCompact) to settings JSON.
+ * Idempotent — skips hooks that already exist. Returns unchanged JSON if all 3 present.
+ */
+export declare function addMemoryHooks(settingsJson: string, devflowDir: string): string;
+/**
+ * Remove all memory hooks (Stop, SessionStart, PreCompact) from settings JSON.
+ * Idempotent — returns unchanged JSON if no memory hooks present.
+ * Preserves non-memory hooks. Cleans empty arrays/objects.
+ */
+export declare function removeMemoryHooks(settingsJson: string): string;
+/**
+ * Check if ALL 3 memory hooks are registered in settings JSON.
+ */
+export declare function hasMemoryHooks(settingsJson: string): boolean;
+/**
+ * Count how many of the 3 memory hooks are present (0-3).
+ */
+export declare function countMemoryHooks(settingsJson: string): number;
+export declare const memoryCommand: Command;
+//# sourceMappingURL=memory.d.ts.map

package/dist/commands/memory.js

@@ -0,0 +1,175 @@
+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 { 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',
+};
+/**
+ * Add all 3 memory hooks (Stop, SessionStart, PreCompact) to settings JSON.
+ * Idempotent — skips hooks that already exist. Returns unchanged JSON if all 3 present.
+ */
+export function addMemoryHooks(settingsJson, devflowDir) {
+    const settings = JSON.parse(settingsJson);
+    if (hasMemoryHooks(settingsJson)) {
+        return settingsJson;
+    }
+    if (!settings.hooks) {
+        settings.hooks = {};
+    }
+    let changed = false;
+    for (const [hookType, marker] of Object.entries(MEMORY_HOOK_CONFIG)) {
+        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 newEntry = {
+                hooks: [
+                    {
+                        type: 'command',
+                        command: hookCommand,
+                        timeout: 10,
+                    },
+                ],
+            };
+            if (!settings.hooks[hookType]) {
+                settings.hooks[hookType] = [];
+            }
+            settings.hooks[hookType].push(newEntry);
+            changed = true;
+        }
+    }
+    if (!changed) {
+        return settingsJson;
+    }
+    return JSON.stringify(settings, null, 2) + '\n';
+}
+/**
+ * Remove all memory hooks (Stop, SessionStart, PreCompact) from settings JSON.
+ * Idempotent — returns unchanged JSON if no memory hooks present.
+ * Preserves non-memory hooks. Cleans empty arrays/objects.
+ */
+export function removeMemoryHooks(settingsJson) {
+    const settings = JSON.parse(settingsJson);
+    if (!settings.hooks) {
+        return settingsJson;
+    }
+    let changed = false;
+    for (const [hookType, marker] of Object.entries(MEMORY_HOOK_CONFIG)) {
+        if (!settings.hooks[hookType]) {
+            continue;
+        }
+        const before = settings.hooks[hookType].length;
+        settings.hooks[hookType] = settings.hooks[hookType].filter((matcher) => !matcher.hooks.some((h) => h.command.includes(marker)));
+        if (settings.hooks[hookType].length !== before) {
+            changed = true;
+        }
+        if (settings.hooks[hookType].length === 0) {
+            delete settings.hooks[hookType];
+        }
+    }
+    if (settings.hooks && Object.keys(settings.hooks).length === 0) {
+        delete settings.hooks;
+    }
+    if (!changed) {
+        return settingsJson;
+    }
+    return JSON.stringify(settings, null, 2) + '\n';
+}
+/**
+ * Check if ALL 3 memory hooks are registered in settings JSON.
+ */
+export function hasMemoryHooks(settingsJson) {
+    return countMemoryHooks(settingsJson) === 3;
+}
+/**
+ * Count how many of the 3 memory hooks are present (0-3).
+ */
+export function countMemoryHooks(settingsJson) {
+    const settings = JSON.parse(settingsJson);
+    if (!settings.hooks) {
+        return 0;
+    }
+    let count = 0;
+    for (const [hookType, marker] of Object.entries(MEMORY_HOOK_CONFIG)) {
+        const matchers = settings.hooks[hookType] ?? [];
+        if (matchers.some((matcher) => matcher.hooks.some((h) => h.command.includes(marker)))) {
+            count++;
+        }
+    }
+    return count;
+}
+export const memoryCommand = new Command('memory')
+    .description('Enable or disable working memory (session context preservation)')
+    .option('--enable', 'Add Stop/SessionStart/PreCompact hooks')
+    .option('--disable', 'Remove memory hooks')
+    .option('--status', 'Show current state')
+    .action(async (options) => {
+    const hasFlag = options.enable || options.disable || options.status;
+    if (!hasFlag) {
+        p.intro(color.bgCyan(color.white(' Working Memory ')));
+        p.note(`${color.cyan('devflow memory --enable')}   Add memory hooks\n` +
+            `${color.cyan('devflow memory --disable')}  Remove memory hooks\n` +
+            `${color.cyan('devflow memory --status')}   Check current state`, 'Usage');
+        p.outro(color.dim('Memory hooks provide automatic session context preservation'));
+        return;
+    }
+    const claudeDir = getClaudeDirectory();
+    const settingsPath = path.join(claudeDir, 'settings.json');
+    let settingsContent;
+    try {
+        settingsContent = await fs.readFile(settingsPath, 'utf-8');
+    }
+    catch {
+        if (options.status) {
+            p.log.info('Working memory: disabled (no settings.json found)');
+            return;
+        }
+        // Create minimal settings.json
+        settingsContent = '{}';
+    }
+    if (options.status) {
+        const count = countMemoryHooks(settingsContent);
+        if (count === 3) {
+            p.log.info(`Working memory: ${color.green('enabled')} (3/3 hooks)`);
+        }
+        else if (count === 0) {
+            p.log.info(`Working memory: ${color.dim('disabled')}`);
+        }
+        else {
+            p.log.info(`Working memory: ${color.yellow(`partial (${count}/3 hooks)`)} — run --enable to fix`);
+        }
+        return;
+    }
+    const devflowDir = getDevFlowDirectory();
+    if (options.enable) {
+        const updated = addMemoryHooks(settingsContent, devflowDir);
+        if (updated === settingsContent) {
+            p.log.info('Working memory already enabled');
+            return;
+        }
+        await fs.writeFile(settingsPath, updated, 'utf-8');
+        await createMemoryDir(false);
+        await migrateMemoryFiles(true);
+        p.log.success('Working memory enabled — Stop/SessionStart/PreCompact hooks registered');
+        p.log.info(color.dim('Session context will be automatically preserved across conversations'));
+    }
+    if (options.disable) {
+        const updated = removeMemoryHooks(settingsContent);
+        if (updated === settingsContent) {
+            p.log.info('Working memory already disabled');
+            return;
+        }
+        await fs.writeFile(settingsPath, updated, 'utf-8');
+        p.log.success('Working memory disabled — hooks removed');
+    }
+});
+//# sourceMappingURL=memory.js.map