claude-dev-env 2.14.0 → 2.15.0

package/bin/install.mjs

@@ -22,10 +22,14 @@ import {
     MANAGED_SKILLS_DIRECTORY_NAME,
     MANAGED_HOOKS_DIRECTORY_NAME,
     SETTINGS_FILE_NAME,
+    CODEX_RULES_PACKAGE_DIRECTORY_NAME,
+    CURSOR_SYNC_SCRIPT_FILE_NAME,
+    WINDOWS_PYTHON_LAUNCHER_COMMAND,
 } from './install-constants.mjs';
 import {
     resolveInstallRoot,
     parseExplicitTargetFromArgv,
+    isAllowedInstallDestination,
 } from './resolve-install-root.mjs';
 import {
     parseInstallTargetSelectionFromArgv,
@@ -211,7 +215,7 @@ function discoverDependencyGroups() {
             readFileSync(join(dependencyRoot, 'package.json'), 'utf8')
         );
         const groupName = dependencyPackageJson.claudeDevEnv?.groupName
-            || dependencyName.replace(/^@[^/]+\//, '');
+            || dependencyName.replace(new RegExp('^@[^/]+/'), '');
         const group = {
             description: dependencyPackageJson.description || dependencyName,
             packageRoot: dependencyRoot,
@@ -257,6 +261,7 @@ export const INSTALL_GROUPS = {
         skills: CORE_SKILLS,
         includeDirectories: CORE_INCLUDE_DIRECTORIES,
         includeAllHooks: true,
+        includeCodexRules: true,
     },
     journal: {
         description: 'Session logging and memory',
@@ -302,6 +307,75 @@ export function isWindowsStorePythonStub(executablePath) {
     return /[\\/]windowsapps[\\/]/i.test(executablePath);
 }
 
+/**
+ * Split a stored Python command into an executable and prefix arguments.
+ *
+ * Args:
+ *   pythonCommand: The command the installer detected (`py -3`, `python3`, or a path).
+ *
+ * Returns:
+ *   `{ file, prefixArguments }` for `execFileSync`.
+ */
+export function pythonFileAndPrefixArguments(pythonCommand) {
+    if (pythonCommand === WINDOWS_PYTHON_LAUNCHER_COMMAND) {
+        return { file: 'py', prefixArguments: ['-3'] };
+    }
+    const unquoted = pythonCommand.replace(/^"(.*)"$/, '$1');
+    return { file: unquoted, prefixArguments: [] };
+}
+
+/**
+ * Read generated Cursor paths from the sync manifest under a Cursor home.
+ *
+ * Args:
+ *   cursorRoot: Absolute `.cursor` directory.
+ *
+ * Returns:
+ *   Absolute paths the installer may record, including the sync manifest.
+ */
+export function collectManagedCursorSyncPaths(cursorRoot) {
+    const manifestPath = join(cursorRoot, '.sync-manifest.json');
+    if (!existsSync(manifestPath)) return [];
+    const parsed = JSON.parse(readFileSync(manifestPath, 'utf8'));
+    const generatedPaths = [manifestPath];
+    const allEntries = { ...(parsed.entries || {}), ...(parsed.docs_entries || {}) };
+    for (const eachRelativePath of Object.keys(allEntries)) {
+        generatedPaths.push(join(cursorRoot, eachRelativePath));
+    }
+    return generatedPaths;
+}
+
+/**
+ * Run the installed Cursor rule generator against Claude and Cursor roots.
+ *
+ * Args:
+ *   pythonCommand: Interpreter command from install preflight.
+ *   scriptPath: Absolute `sync_to_cursor.py` path.
+ *   claudeRoot: Managed Claude root that holds `rules/` and `docs/`.
+ *   cursorRoot: Cursor home that receives `rules/*.mdc`.
+ *
+ * Returns:
+ *   void
+ */
+export function runCursorRuleSync(pythonCommand, scriptPath, claudeRoot, cursorRoot) {
+    mkdirSync(cursorRoot, { recursive: true });
+    const { file, prefixArguments } = pythonFileAndPrefixArguments(pythonCommand);
+    execFileSync(
+        file,
+        [
+            ...prefixArguments,
+            scriptPath,
+            '--force',
+            '--quiet',
+            '--claude-root',
+            claudeRoot,
+            '--cursor-root',
+            cursorRoot,
+        ],
+        { stdio: 'inherit' },
+    );
+}
+
 /**
  * Formats an absolute interpreter path as a settings.json hook command prefix:
  * forward-slash separators, double-quoted when the path contains a space so the
@@ -629,8 +703,7 @@ function isManagedPath(candidatePath, managedHomeDirectory = CLAUDE_HOME) {
  * @returns {boolean} True when the installer itself writes the path.
  */
 function isRemovableManifestRecord(candidatePath) {
-    if (isManagedPath(candidatePath)) return true;
-    return comparisonKeyForPath(candidatePath) === comparisonKeyForPath(MYPY_INI_INSTALL_PATH);
+    return isAllowedInstallDestination(candidatePath, INSTALL_ROOT_RESOLUTION);
 }
 
 /**
@@ -650,6 +723,10 @@ function owningManagedRoot(installedFilePath) {
         const managedRoot = join(CLAUDE_HOME, directoryName);
         if (isInsideDirectory(resolvedPath, managedRoot)) return managedRoot;
     }
+    const codexRulesDirectory = INSTALL_ROOT_RESOLUTION.codexRulesInstallDirectory;
+    if (isInsideDirectory(resolvedPath, codexRulesDirectory)) return codexRulesDirectory;
+    const cursorInstallDirectory = INSTALL_ROOT_RESOLUTION.cursorInstallDirectory;
+    if (isInsideDirectory(resolvedPath, cursorInstallDirectory)) return cursorInstallDirectory;
     return null;
 }
 
@@ -1856,7 +1933,7 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
             `${PACKAGE_NAME}: --update — removing prior managed files under ${CLAUDE_HOME}, then reinstalling from the package.\n`,
         );
         purgeManagedInstallation({
-            requireManifest: false,
+            isManifestRequired: false,
             throwIfFault,
         });
     } else if (isUpdateRefresh) {
@@ -1940,6 +2017,30 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
             }
         }
     }
+    const shouldInstallCodexRules = !selectedGroups
+        || activeGroups.some((eachGroup) => eachGroup.includeCodexRules);
+    if (shouldInstallCodexRules) {
+        const sourceDirectory = join(PACKAGE_ROOT, CODEX_RULES_PACKAGE_DIRECTORY_NAME);
+        if (existsSync(sourceDirectory)) {
+            const destinationDirectory = INSTALL_ROOT_RESOLUTION.codexRulesInstallDirectory;
+            const stats = copyTree(sourceDirectory, destinationDirectory);
+            summary.codexRules = stats;
+            allInstalledFiles.push(...stats.paths);
+        }
+    }
+    const shouldInstallCursorRules = !selectedGroups
+        || activeGroups.some((eachGroup) => (eachGroup.includeDirectories || []).includes('rules'));
+    if (shouldInstallCursorRules) {
+        const scriptPath = join(CLAUDE_HOME, 'scripts', CURSOR_SYNC_SCRIPT_FILE_NAME);
+        if (!existsSync(scriptPath)) {
+            throw new Error(`cursor rule sync script missing: ${scriptPath}`);
+        }
+        const cursorRoot = dirname(INSTALL_ROOT_RESOLUTION.cursorRulesInstallDirectory);
+        runCursorRuleSync(pythonCommand, scriptPath, CLAUDE_HOME, cursorRoot);
+        const generatedCursorPaths = collectManagedCursorSyncPaths(cursorRoot);
+        allInstalledFiles.push(...generatedCursorPaths);
+        summary.cursorRules = { created: generatedCursorPaths.length, updated: 0, paths: generatedCursorPaths };
+    }
     let skillsCreated = 0;
     let skillsUpdated = 0;
     const skillPaths = [];
@@ -2136,6 +2237,14 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
             console.log(`  ${directory}: ${created + updated} files (${created} new, ${updated} updated)`);
         }
     }
+    if (summary.codexRules) {
+        const { created, updated } = summary.codexRules;
+        console.log(`  ${CODEX_RULES_PACKAGE_DIRECTORY_NAME}: ${created + updated} files (${created} new, ${updated} updated)`);
+    }
+    if (summary.cursorRules) {
+        const { created } = summary.cursorRules;
+        console.log(`  cursor-rules: ${created} generated files`);
+    }
     if (summary.skills) {
         const { created, updated, pruned } = summary.skills;
         const staleClause = pruned > 0 ? `, ${pruned} stale moved aside` : '';
@@ -2222,14 +2331,14 @@ function removeRecordedFile(filePath) {
 /**
  * Build the uninstall plan for this managed root.
  *
- * @param {boolean} requireManifest
+ * @param {boolean} isManifestRequired
  * @returns {ReturnType<typeof buildUninstallPlan>}
  */
-function resolveUninstallPlan(requireManifest) {
+function resolveUninstallPlan(isManifestRequired) {
     return buildUninstallPlan({
         managedRoot: CLAUDE_HOME,
         manifestFilePath: MANIFEST_FILE,
-        requireManifest,
+        requireManifest: isManifestRequired,
         isRemovableRecord: isRemovableManifestRecord,
     });
 }
@@ -2266,20 +2375,20 @@ function executeUninstallPlan(plan, helpers = {}) {
     }
     if (plan.skippedFiles.length > 0) {
         console.warn(
-            `  ${plan.skippedFiles.length} manifest record(s) skipped — each names a path outside ${CLAUDE_HOME} and outside ${MYPY_INI_INSTALL_PATH}`,
+            `  ${plan.skippedFiles.length} manifest record(s) skipped — each names a path outside ${CLAUDE_HOME}, outside ${MYPY_INI_INSTALL_PATH}, outside ${INSTALL_ROOT_RESOLUTION.codexRulesInstallDirectory}, and outside ${INSTALL_ROOT_RESOLUTION.cursorInstallDirectory}`,
         );
     }
     throwIfFault(FAULT_PHASES.AFTER_FILE_STAGING);
 
     if (existsSync(plan.settingsPath)) {
         const settings = JSON.parse(readFileSync(plan.settingsPath, 'utf8'));
-        let settingsChanged = false;
+        let didSettingsChange = false;
         if (settings.hooks) {
             const managedHookRelativePaths = managedHookScriptRelativePathsFromSourceRoots(
                 managedPackageSourceRoots(),
             );
             pruneManagedHooksFromSettings(settings, managedHookRelativePaths);
-            settingsChanged = true;
+            didSettingsChange = true;
             console.log('  Hook entries removed from settings.json');
         }
         const managedDenyFromPlan = plan.managedPermissionDenyEntries.length > 0
@@ -2288,13 +2397,13 @@ function executeUninstallPlan(plan, helpers = {}) {
         if (managedDenyFromPlan.length > 0) {
             const pruneOutcome = pruneManagedPermissionsFromSettings(settings, managedDenyFromPlan);
             if (pruneOutcome.removedCount > 0) {
-                settingsChanged = true;
+                didSettingsChange = true;
                 console.log(
                     `  Permission entries removed from settings.json: ${pruneOutcome.removedCount} managed deny(s)`,
                 );
             }
         }
-        if (settingsChanged) {
+        if (didSettingsChange) {
             writeFileSync(plan.settingsPath, JSON.stringify(settings, null, 4) + '\n');
         }
     }
@@ -2327,13 +2436,13 @@ function executeUninstallPlan(plan, helpers = {}) {
  * without nesting a second journal.
  *
  * @param {{
- *   requireManifest: boolean,
+ *   isManifestRequired: boolean,
  *   throwIfFault?: (phase: string) => void,
  * }} options
  * @returns {number|void} 0 when no manifest exists and none is required.
  */
-function purgeManagedInstallation({ requireManifest, throwIfFault }) {
-    const plan = resolveUninstallPlan(requireManifest);
+function purgeManagedInstallation({ isManifestRequired, throwIfFault }) {
+    const plan = resolveUninstallPlan(isManifestRequired);
     if (plan.isNoOp) {
         return 0;
     }
@@ -2433,6 +2542,8 @@ Examples:
 
 Install location: ~/.claude/ by default; CLAUDE_CONFIG_DIR or --target selects another managed root.
 Named profiles resolve under LLM_SETTINGS_PROFILES_ROOT or ~/.claude-profiles/<directoryName>.
+Codex exec-policy files copy into ~/.codex/rules, or CODEX_HOME/rules when CODEX_HOME is set.
+Cursor rule files generate into ~/.cursor/rules as stem-named mdc files, one per Claude rule.
 
 Root precedence: --target > CLAUDE_CONFIG_DIR > ~/.claude
 Profile selection (--profile/--profiles) is mutually exclusive with --target.
@@ -2564,7 +2675,7 @@ function runInstallForAllTargets(allTargets, childArgv) {
  * @returns {number | null}
  */
 function spawnInstallChild(target, childArgv) {
-    const result = spawnSync(
+    const childProcess = spawnSync(
         process.execPath,
         [
             fileURLToPath(import.meta.url),
@@ -2579,11 +2690,11 @@ function spawnInstallChild(target, childArgv) {
             env: process.env,
         },
     );
-    if (result.error) {
-        console.error(`ERROR: failed to spawn install child: ${result.error.message}`);
+    if (childProcess.error) {
+        console.error(`ERROR: failed to spawn install child: ${childProcess.error.message}`);
         return 1;
     }
-    return result.status === null ? 1 : result.status;
+    return childProcess.status === null ? 1 : childProcess.status;
 }
 
 if (invokedAsEntryPoint(import.meta.url, process.argv[1])) {

package/bin/install.profile-root.test.mjs

@@ -8,6 +8,7 @@ import { join, resolve } from 'node:path';
 import { mkdtempSync, rmSync, mkdirSync, readFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { fileURLToPath } from 'node:url';
+import { CODEX_RULES_SHIPPED_FILE_NAME } from './install-constants.mjs';
 import {
     resolveInstallRoot,
     isPathWithinManagedRoot,
@@ -90,6 +91,13 @@ test('declared external mypy.ini is allowed; unrelated external paths are not',
         isAllowedInstallDestination(join(resolution.managedRoot, 'hooks', 'x.py'), resolution),
         true,
     );
+    assert.equal(
+        isAllowedInstallDestination(
+            join(resolution.codexRulesInstallDirectory, CODEX_RULES_SHIPPED_FILE_NAME),
+            resolution,
+        ),
+        true,
+    );
 });
 
 test('parseExplicitTargetFromArgv reads --target and --target=', () => {

package/bin/install.prune.test.mjs

@@ -238,6 +238,7 @@ function resolveInstallerInvocation(homeDirectory, options) {
         HOME: homeDirectory,
         USERPROFILE: homeDirectory,
         GIT_CONFIG_GLOBAL: join(homeDirectory, '.gitconfig'),
+        CODEX_HOME: join(homeDirectory, '.codex'),
     };
     if (dependencyResolvable) {
         childEnvironment.NODE_PATH = ensureDependencyStub(homeDirectory);
@@ -1227,7 +1228,7 @@ test('an uninstall removes the home-directory .mypy.ini the install wrote and sk
         assert.equal(
             existsSync(mypyIniPath),
             false,
-            'the uninstall removes the one file the install writes outside ~/.claude',
+            'the uninstall removes the mypy configuration the install writes outside ~/.claude',
         );
         assert.equal(
             installerOutput.includes(`skipping ${mypyIniPath}`),

package/bin/install.test.mjs

@@ -1672,15 +1672,15 @@ test('copyTree copies AGENTS.md with agent definitions', () => {
     const destinationRoot = mkdtempSync(join(tmpdir(), 'cdev-copy-agents-destination-'));
     try {
         writeFileSync(join(sourceRoot, 'AGENTS.md'), '# Shared guidance\n');
-        const agentDefinitionPath = join(sourceRoot, 'docs-agent.md');
+        const agentDefinitionPath = join(sourceRoot, 'clean-coder.md');
         writeFileSync(
             agentDefinitionPath,
-            '---\nname: docs-agent\ndescription: fixture agent\n---\n',
+            '---\nname: clean-coder\ndescription: fixture agent\n---\n',
         );
 
         const copyStats = copyTree(sourceRoot, destinationRoot);
         const copiedAgentsPath = join(destinationRoot, 'AGENTS.md');
-        const copiedAgentPath = join(destinationRoot, 'docs-agent.md');
+        const copiedAgentPath = join(destinationRoot, 'clean-coder.md');
 
         assert.equal(existsSync(copiedAgentsPath), true, 'the canonical instructions install');
         assert.equal(existsSync(copiedAgentPath), true, 'the real agent definition installs');

package/bin/install.transaction.test.mjs

@@ -242,6 +242,7 @@ function runInstaller(homeDirectory, extraArguments, options = {}) {
         HOME: homeDirectory,
         USERPROFILE: homeDirectory,
         GIT_CONFIG_GLOBAL: join(homeDirectory, '.gitconfig'),
+        CODEX_HOME: join(homeDirectory, '.codex'),
     };
     if (options.faultPhase) {
         childEnvironment[INSTALL_FAULT_ENV] = options.faultPhase;

package/bin/install.uninstall-transaction.test.mjs

@@ -74,6 +74,7 @@ function runInstaller(homeDirectory, extraArguments, options = {}) {
         HOME: homeDirectory,
         USERPROFILE: homeDirectory,
         GIT_CONFIG_GLOBAL: join(homeDirectory, '.gitconfig'),
+        CODEX_HOME: join(homeDirectory, '.codex'),
     };
     if (options.faultPhase) {
         childEnvironment[INSTALL_FAULT_ENV] = options.faultPhase;

package/bin/resolve-install-root.mjs

@@ -11,7 +11,14 @@
 
 import { homedir } from 'node:os';
 import { join, normalize, resolve, sep } from 'node:path';
-import { MYPY_INI_FILE_NAME } from './install-constants.mjs';
+import {
+    MYPY_INI_FILE_NAME,
+    CODEX_HOME_ENVIRONMENT_VARIABLE,
+    DEFAULT_CODEX_DIRECTORY_NAME,
+    CODEX_RULES_DIRECTORY_NAME,
+    DEFAULT_CURSOR_DIRECTORY_NAME,
+    CURSOR_RULES_DIRECTORY_NAME,
+} from './install-constants.mjs';
 
 export const CLAUDE_CONFIG_DIR_ENVIRONMENT_VARIABLE = 'CLAUDE_CONFIG_DIR';
 export const DEFAULT_CLAUDE_DIRECTORY_NAME = '.claude';
@@ -33,6 +40,10 @@ export const MANIFEST_FILE_NAME = '.claude-dev-env-manifest.json';
  *   manifestFilePath: string,
  *   mypyIniInstallPath: string,
  *   allDeclaredExternalPaths: string[],
+ *   allDeclaredExternalDirectories: string[],
+ *   codexRulesInstallDirectory: string,
+ *   cursorInstallDirectory: string,
+ *   cursorRulesInstallDirectory: string,
  * }} InstallRootResolution
  */
 
@@ -69,6 +80,18 @@ export function resolveInstallRoot(options = {}) {
     }
 
     const mypyIniInstallPath = resolve(join(homeDirectory, MYPY_INI_FILE_NAME));
+    const codexHomeDirectory = normalizeOptionalPath(
+        environment[CODEX_HOME_ENVIRONMENT_VARIABLE],
+    ) ?? resolve(join(homeDirectory, DEFAULT_CODEX_DIRECTORY_NAME));
+    const codexRulesInstallDirectory = resolve(
+        join(codexHomeDirectory, CODEX_RULES_DIRECTORY_NAME),
+    );
+    const cursorInstallDirectory = resolve(
+        join(homeDirectory, DEFAULT_CURSOR_DIRECTORY_NAME),
+    );
+    const cursorRulesInstallDirectory = resolve(
+        join(cursorInstallDirectory, CURSOR_RULES_DIRECTORY_NAME),
+    );
     return {
         managedRoot,
         source,
@@ -76,6 +99,10 @@ export function resolveInstallRoot(options = {}) {
         manifestFilePath: join(managedRoot, MANIFEST_FILE_NAME),
         mypyIniInstallPath,
         allDeclaredExternalPaths: [mypyIniInstallPath],
+        allDeclaredExternalDirectories: [codexRulesInstallDirectory, cursorInstallDirectory],
+        codexRulesInstallDirectory,
+        cursorInstallDirectory,
+        cursorRulesInstallDirectory,
     };
 }
 
@@ -103,8 +130,9 @@ export function isPathWithinManagedRoot(candidatePath, managedRoot) {
 }
 
 /**
- * True when a write destination is allowed: inside the managed root or on
- * the declared external allowlist (today: ~/.mypy.ini under the home dir).
+ * True when a write destination is allowed: inside the managed root, the
+ * home-directory `.mypy.ini`, a file under the Codex rules directory, or a file
+ * under the Cursor rules directory.
  *
  * @param {string} candidatePath
  * @param {InstallRootResolution} resolution
@@ -115,8 +143,13 @@ export function isAllowedInstallDestination(candidatePath, resolution) {
         return true;
     }
     const normalizedCandidate = normalizePathForComparison(candidatePath);
-    return resolution.allDeclaredExternalPaths.some(
+    if (resolution.allDeclaredExternalPaths.some(
         (eachExternalPath) => normalizePathForComparison(eachExternalPath) === normalizedCandidate,
+    )) {
+        return true;
+    }
+    return (resolution.allDeclaredExternalDirectories ?? []).some(
+        (eachExternalDirectory) => isPathWithinManagedRoot(candidatePath, eachExternalDirectory),
     );
 }
 
@@ -130,18 +163,18 @@ export function parseExplicitTargetFromArgv(argv) {
     for (let index = 0; index < argv.length; index += 1) {
         const token = argv[index];
         if (token === '--target') {
-            const value = argv[index + 1];
-            if (!value || value.startsWith('--')) {
+            const targetPath = argv[index + 1];
+            if (!targetPath || targetPath.startsWith('--')) {
                 throw new Error('--target requires a path argument');
             }
-            return value;
+            return targetPath;
         }
         if (token.startsWith('--target=')) {
-            const value = token.slice('--target='.length);
-            if (!value) {
+            const targetPath = token.slice('--target='.length);
+            if (!targetPath) {
                 throw new Error('--target requires a path argument');
             }
-            return value;
+            return targetPath;
         }
     }
     return null;

package/codex-rules/claude-dev-env.rules

@@ -0,0 +1,12 @@
+# Shared Codex exec-policy prefix rules shipped by claude-dev-env.
+# Codex loads every *.rules file under $CODEX_HOME/rules (default ~/.codex/rules).
+# This file is named claude-dev-env.rules so a local default.rules stays in place.
+# Patterns use relative repo paths only. Personal home paths stay out of this file.
+
+prefix_rule(pattern=["gemini", "--version"], decision="allow")
+prefix_rule(pattern=["git", "status", "--short", "--branch"], decision="allow")
+prefix_rule(pattern=["git", "status", "--short"], decision="allow")
+prefix_rule(pattern=["git", "diff", "--", "packages/claude-dev-env/_shared/pr-loop/scripts/code_rules_gate_parts", "packages/claude-dev-env/_shared/pr-loop/scripts/tests/test_code_rules_gate.py"], decision="allow")
+prefix_rule(pattern=["Get-Content", "-LiteralPath", "packages/claude-dev-env/_shared/pr-loop/scripts/code_rules_gate_parts/tests/_repo_test_helpers.py"], decision="allow")
+prefix_rule(pattern=["rg", "-n", "-i", "--glob", "!**/__pycache__/**", "verified_commit_gate|verifier_verdict_minter|verdict_directory_write_blocker|verify-skip|code-verifier.*commit|commit.*code-verifier", "packages/claude-dev-env"], decision="allow")
+prefix_rule(pattern=["python", "-m", "pytest", "-q", "packages/claude-dev-env/hooks/hooks_constants/test_bash_pre_tool_use_dispatcher_constants.py", "packages/claude-dev-env/hooks/blocking/test_bash_pre_tool_use_dispatcher.py", "packages/claude-dev-env/hooks/blocking/test_pre_tool_use_dispatcher.py", "packages/claude-dev-env/hooks/blocking/test_verdict_directory_write_blocker.py"], decision="allow")

package/commands/AGENTS.md

@@ -6,17 +6,7 @@ Slash-command definitions installed into `~/.claude/commands/` by `bin/install.m
 
 | File | Command | What it does |
 |---|---|---|
-| `commit.md` | `/commit` | Commits and pushes changes to GitHub |
-| `docupdate.md` | `/docupdate` | Updates documentation to match current code state |
-| `hook-log-extract.md` | `/hook-log-extract` | Extracts and formats hook log entries for a session |
-| `hook-log-init.md` | `/hook-log-init` | Initializes the Neon Postgres schema that backs the hook-log extractor (one-time per machine) |
-| `implement.md` | `/implement` | Provides full implementation context to a right-sized engineer in XML format |
-| `plan.md` | `/plan` | Plans a feature through the `anthropic-plan` skill and workflow |
-| `pr-comments.md` | `/pr-comments` | Fetches and formats PR review comments for response |
-| `review-plan.md` | `/review-plan` | Reviews the current plan packet against code standards |
-| `right-size.md` | `/right-size` | Checks an implementation against the Right-Sized Engineering rules |
 | `sr-loop.md` | `/sr-loop` | Runs the converging cleanup loop: /simplify passes until clean, then a code-review fix pass |
-| `sum.md` | `/sum` | Generates a formatted session summary for quick pickup in a new session |
 
 ## Format
 

package/hooks/blocking/test_claude_md_orphan_file_blocker.py

@@ -47,7 +47,7 @@ TABLE_WITH_SLASH_COMMAND_AND_SUBDIR = (
     "# example\n\n"
     "| Entry | Description |\n"
     "|---|---|\n"
-    "| `/commit` | Slash command |\n"
+    "| `/sr-loop` | Slash command |\n"
     "| `scripts/` | A subdirectory |\n"
     "| Plain prose, no backticks | Not a file |\n"
 )

package/hooks/diagnostic/AGENTS.md

@@ -41,3 +41,35 @@ The `blocked_commands` view filters to `outcome = 'blocked'`.
 - Extractor and Stop wrapper mains are disabled and exit 0 with no work.
 - Constants for the extractor (table name, offset state file, timeout) live in `hooks_constants/hook_log_extractor_constants.py`.
 - Tests run with `python -m pytest diagnostic/test_hook_log_*.py`.
+
+## Schema init
+
+Run `hook_log_init.py` once per machine, or after rotating the Neon project.
+
+Prerequisites: Bitwarden Secrets Manager CLI (`bws`) on PATH; a machine-account
+token in `BWS_ACCESS_TOKEN` for the user environment (`setx` on Windows, shell
+profile on macOS/Linux); Neon connection string stored as
+`NEON_HOOK_LOGS_DATABASE_URL`; Python deps from `requirements-hook-logs.txt`.
+
+```
+bws run -- python packages/claude-dev-env/hooks/diagnostic/hook_log_init.py
+```
+
+`bws run` strips `BWS_ACCESS_TOKEN` from the child environment so the Python
+process never sees it. The script verifies `NEON_HOOK_LOGS_DATABASE_URL`,
+connects with a 5-second timeout, applies `schema.sql` with idempotent DDL,
+runs a sentinel insert/select/delete round-trip, and prints the Neon host,
+table name, and row count.
+
+## Operator CLI flags
+
+`hook_log_extractor.py` and `hook_log_stop_wrapper.py` mains exit 0 with no work.
+The extractor body still documents these flags for a re-enable path:
+
+- default / `--incremental`: resume from `~/.claude/logs/hooks/.state/offsets.json`
+- `--full-rebuild`: clear offsets, truncate `hook_events`, re-read every JSONL
+- `--summary`: print the top-10 blockers of the last 24 hours
+- `--query <name>`: run `queries/<name>.sql` (`top_blockers_overall`,
+  `top_blockers_last_24_hours`, `blocks_last_7_days`, `blocks_by_category`,
+  `blocks_by_tool`, `block_details_for_hook`)
+

package/hooks/diagnostic/hook_log_init.py

@@ -66,7 +66,7 @@ def verify_environment_variables() -> list[str]:
     child process invoked via ``bws run -- python hook_log_init.py``
     would therefore always fail even when the machine is configured
     correctly. The one-time ``setx BWS_ACCESS_TOKEN`` prerequisite is
-    documented in ``packages/claude-dev-env/commands/hook-log-init.md``.
+    documented in ``packages/claude-dev-env/hooks/diagnostic/AGENTS.md``.
     """
     all_missing_variable_names: list[str] = []
     raw_database_url_value = os.environ.get(NEON_DATABASE_URL_ENVIRONMENT_VARIABLE)
@@ -172,7 +172,7 @@ def _print_missing_environment_variables(all_missing_variable_names: list[str])
 
 
 def main() -> int:
-    """Entry point for the ``/hook-log-init`` slash command."""
+    """CLI entry for one-time Neon schema init."""
     all_missing_variable_names = verify_environment_variables()
     if all_missing_variable_names:
         _print_missing_environment_variables(all_missing_variable_names)

package/output-styles/AGENTS.md

@@ -4,7 +4,7 @@ Output-style instruction files installed into `~/.claude/output-styles/` by `bin
 
 ## Files
 
-No output-style instruction files ship in this directory. The active caveman behavior lives in `agents/caveman.md`.
+No output-style instruction files ship in this directory.
 
 ## Format
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "2.14.0",
+    "version": "2.15.0",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {
@@ -26,6 +26,7 @@
         "installable-surfaces.manifest.json",
         "_shared/",
         "audit-rubrics/",
+        "codex-rules/",
         "AGENTS.md",
         "CLAUDE.md",
         "!**/__pycache__/**",

package/scripts/sync_to_cursor/AGENTS.md

@@ -6,12 +6,12 @@ Python package that syncs Claude rules and docs to Cursor `.mdc` files. Entry po
 
 | File | Purpose |
 |---|---|
-| `engine.py` | Main sync logic: loads the manifest, builds rule mappings, hashes sources, writes `.mdc` files, and updates the manifest |
-| `rules.py` | Builds `RuleMapping` objects from Claude rule markdown files; applies transforms to fit Cursor's `.mdc` format |
+| `engine.py` | Main sync logic: loads the manifest, builds rule mappings, hashes sources, writes `.mdc` files, and updates the manifest; `--claude-root` and `--cursor-root` select explicit layouts |
+| `rules.py` | Builds `RuleMapping` objects from Claude rule markdown files; applies transforms to fit Cursor's `.mdc` format; maps remaining `rules/*.md` files to `<stem>.mdc` |
 | `canonical_docs.py` | Checks and syncs canonical documentation files (`CODE_RULES.md`, `TEST_QUALITY.md`) to the Cursor rules directory |
 | `paths.py` | Resolves the Claude and Cursor layout paths; respects the `LLM_SETTINGS_ROOT` env var for non-home layouts |
 | `hashing.py` | SHA-256 helpers that detect whether source files changed since the last sync run |
-| `config.py` | Package-level constants: `GENERATOR_VERSION`, `CANONICAL_DOC_FILES`, `MAX_RULE_BODY_LINES` |
+| `config/` | Package-level constants: `GENERATOR_VERSION`, `ALL_CANONICAL_DOC_FILES`, `MAX_RULE_BODY_LINES`, skipped inventory filenames, markdown suffix |
 | `__init__.py` | Empty package marker |
 
 ## Layout resolution