claude-dev-env 2.15.1 → 2.17.0

package/bin/publish-directory-pointer.test.mjs

@@ -0,0 +1,129 @@
+/**
+ * Real-filesystem tests for Claude lookup pointers into the agents home.
+ */
+
+import { test } from 'node:test';
+import { strict as assert } from 'node:assert';
+import {
+    existsSync,
+    lstatSync,
+    mkdirSync,
+    mkdtempSync,
+    readFileSync,
+    realpathSync,
+    rmSync,
+    writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+    DIRECTORY_POINTER_TYPE_DIR,
+    DIRECTORY_POINTER_TYPE_JUNCTION,
+    POINTER_ACTION_ALREADY_POINTING,
+    POINTER_ACTION_CREATED,
+    directoryPointerTypeForPlatform,
+    ensureDirectoryPointer,
+    isDirectoryPointerTo,
+    unlinkDirectoryPointerIfMatch,
+} from './publish-directory-pointer.mjs';
+
+function makeSandbox() {
+    const root = mkdtempSync(join(tmpdir(), 'cdev-pointer-'));
+    return {
+        root,
+        pointerPath: join(root, 'lookup', 'skills'),
+        targetPath: join(root, 'canonical', 'skills'),
+    };
+}
+
+test('directoryPointerTypeForPlatform uses a junction on Windows and a dir pointer elsewhere', () => {
+    assert.equal(directoryPointerTypeForPlatform('win32'), DIRECTORY_POINTER_TYPE_JUNCTION);
+    assert.equal(directoryPointerTypeForPlatform('linux'), DIRECTORY_POINTER_TYPE_DIR);
+    assert.equal(directoryPointerTypeForPlatform('darwin'), DIRECTORY_POINTER_TYPE_DIR);
+});
+
+test('ensureDirectoryPointer writes a lookup pointer whose files are the canonical files', () => {
+    const sandbox = makeSandbox();
+    try {
+        mkdirSync(sandbox.targetPath, { recursive: true });
+        const canonicalFile = join(sandbox.targetPath, 'notes.md');
+        writeFileSync(canonicalFile, 'canonical body\n');
+
+        const publication = ensureDirectoryPointer(sandbox.pointerPath, sandbox.targetPath);
+        assert.equal(publication.action, POINTER_ACTION_CREATED);
+        assert.equal(lstatSync(sandbox.pointerPath).isSymbolicLink(), true);
+        assert.equal(isDirectoryPointerTo(sandbox.pointerPath, sandbox.targetPath), true);
+        assert.equal(
+            readFileSync(join(sandbox.pointerPath, 'notes.md'), 'utf8'),
+            'canonical body\n',
+        );
+        assert.equal(
+            realpathSync(join(sandbox.pointerPath, 'notes.md')),
+            realpathSync(canonicalFile),
+        );
+    } finally {
+        rmSync(sandbox.root, { recursive: true, force: true });
+    }
+});
+
+test('ensureDirectoryPointer leaves a correct pointer in place', () => {
+    const sandbox = makeSandbox();
+    try {
+        const firstPublication = ensureDirectoryPointer(sandbox.pointerPath, sandbox.targetPath);
+        assert.equal(firstPublication.action, POINTER_ACTION_CREATED);
+        const secondPublication = ensureDirectoryPointer(sandbox.pointerPath, sandbox.targetPath);
+        assert.equal(secondPublication.action, POINTER_ACTION_ALREADY_POINTING);
+        assert.equal(isDirectoryPointerTo(sandbox.pointerPath, sandbox.targetPath), true);
+    } finally {
+        rmSync(sandbox.root, { recursive: true, force: true });
+    }
+});
+
+test('ensureDirectoryPointer relocates a real lookup directory into the agents home', () => {
+    const sandbox = makeSandbox();
+    try {
+        mkdirSync(sandbox.pointerPath, { recursive: true });
+        writeFileSync(join(sandbox.pointerPath, 'personal.md'), 'user skill\n');
+        mkdirSync(sandbox.targetPath, { recursive: true });
+        writeFileSync(join(sandbox.targetPath, 'shipped.md'), 'package skill\n');
+
+        ensureDirectoryPointer(sandbox.pointerPath, sandbox.targetPath);
+
+        assert.equal(lstatSync(sandbox.pointerPath).isSymbolicLink(), true);
+        assert.equal(
+            readFileSync(join(sandbox.targetPath, 'personal.md'), 'utf8'),
+            'user skill\n',
+        );
+        assert.equal(
+            readFileSync(join(sandbox.pointerPath, 'personal.md'), 'utf8'),
+            'user skill\n',
+        );
+        assert.equal(
+            readFileSync(join(sandbox.pointerPath, 'shipped.md'), 'utf8'),
+            'package skill\n',
+        );
+        assert.equal(existsSync(join(sandbox.targetPath, 'personal.md')), true);
+    } finally {
+        rmSync(sandbox.root, { recursive: true, force: true });
+    }
+});
+
+test('unlinkDirectoryPointerIfMatch removes only a pointer that aims at the expected target', () => {
+    const sandbox = makeSandbox();
+    try {
+        ensureDirectoryPointer(sandbox.pointerPath, sandbox.targetPath);
+        writeFileSync(join(sandbox.targetPath, 'kept.md'), 'kept\n');
+        assert.equal(
+            unlinkDirectoryPointerIfMatch(sandbox.pointerPath, sandbox.targetPath),
+            true,
+        );
+        assert.equal(existsSync(sandbox.pointerPath), false);
+        assert.equal(readFileSync(join(sandbox.targetPath, 'kept.md'), 'utf8'), 'kept\n');
+        assert.equal(
+            unlinkDirectoryPointerIfMatch(sandbox.pointerPath, sandbox.targetPath),
+            false,
+        );
+    } finally {
+        rmSync(sandbox.root, { recursive: true, force: true });
+    }
+});

package/bin/resolve-install-root.mjs

@@ -10,7 +10,7 @@
  */
 
 import { homedir } from 'node:os';
-import { join, normalize, resolve, sep } from 'node:path';
+import { basename, dirname, join, normalize, resolve, sep } from 'node:path';
 import {
     MYPY_INI_FILE_NAME,
     CODEX_HOME_ENVIRONMENT_VARIABLE,
@@ -18,10 +18,16 @@ import {
     CODEX_RULES_DIRECTORY_NAME,
     DEFAULT_CURSOR_DIRECTORY_NAME,
     CURSOR_RULES_DIRECTORY_NAME,
+    MANAGED_SKILLS_DIRECTORY_NAME,
+    MANAGED_AGENTS_DIRECTORY_NAME,
+    MANAGED_HOOKS_DIRECTORY_NAME,
+    MANAGED_SCRIPTS_DIRECTORY_NAME,
+    CODEX_HOOKS_DIRECTORY_NAME,
 } from './install-constants.mjs';
 
 export const CLAUDE_CONFIG_DIR_ENVIRONMENT_VARIABLE = 'CLAUDE_CONFIG_DIR';
 export const DEFAULT_CLAUDE_DIRECTORY_NAME = '.claude';
+export const DEFAULT_AGENTS_DIRECTORY_NAME = '.agents';
 export const MANIFEST_FILE_NAME = '.claude-dev-env-manifest.json';
 
 /**
@@ -44,9 +50,52 @@ export const MANIFEST_FILE_NAME = '.claude-dev-env-manifest.json';
  *   codexRulesInstallDirectory: string,
  *   cursorInstallDirectory: string,
  *   cursorRulesInstallDirectory: string,
+ *   agentsHome: string,
+ *   skillsInstallDirectory: string,
+ *   agentsInstallDirectory: string,
+ *   skillsLookupDirectory: string,
+ *   agentsLookupDirectory: string,
+ *   hooksInstallDirectory: string,
+ *   scriptsInstallDirectory: string,
+ *   hooksLookupDirectory: string,
+ *   scriptsLookupDirectory: string,
+ *   codexHooksInstallDirectory: string,
  * }} InstallRootResolution
  */
 
+/**
+ * Resolve the canonical skills/agents home for one managed Claude root.
+ *
+ * When the managed root's base name is `.claude`, the agents home is the sibling
+ * `.agents` directory (so `~/.claude` pairs with `~/.agents`). Any other managed
+ * root — a named profile directory or an explicit `--target` — pairs with a
+ * sibling named `<root-name>.agents`, so two profile directories never share one
+ * agents home.
+ *
+ * @param {string} managedRoot Absolute managed Claude root.
+ * @returns {string} Absolute agents home.
+ */
+export function resolveAgentsHome(managedRoot) {
+    const resolvedManagedRoot = resolve(managedRoot);
+    const parentDirectory = dirname(resolvedManagedRoot);
+    const managedBaseName = basename(resolvedManagedRoot);
+    if (isClaudeDirectoryBaseName(managedBaseName)) {
+        return resolve(join(parentDirectory, DEFAULT_AGENTS_DIRECTORY_NAME));
+    }
+    return resolve(join(parentDirectory, `${managedBaseName}${DEFAULT_AGENTS_DIRECTORY_NAME}`));
+}
+
+/**
+ * @param {string} directoryName
+ * @returns {boolean}
+ */
+function isClaudeDirectoryBaseName(directoryName) {
+    if (process.platform === 'win32') {
+        return directoryName.toLowerCase() === DEFAULT_CLAUDE_DIRECTORY_NAME.toLowerCase();
+    }
+    return directoryName === DEFAULT_CLAUDE_DIRECTORY_NAME;
+}
+
 /**
  * Resolve the managed install root and declared external destinations.
  *
@@ -86,12 +135,24 @@ export function resolveInstallRoot(options = {}) {
     const codexRulesInstallDirectory = resolve(
         join(codexHomeDirectory, CODEX_RULES_DIRECTORY_NAME),
     );
+    const codexHooksInstallDirectory = resolve(
+        join(codexHomeDirectory, CODEX_HOOKS_DIRECTORY_NAME),
+    );
     const cursorInstallDirectory = resolve(
         join(homeDirectory, DEFAULT_CURSOR_DIRECTORY_NAME),
     );
     const cursorRulesInstallDirectory = resolve(
         join(cursorInstallDirectory, CURSOR_RULES_DIRECTORY_NAME),
     );
+    const agentsHome = resolveAgentsHome(managedRoot);
+    const skillsInstallDirectory = join(agentsHome, MANAGED_SKILLS_DIRECTORY_NAME);
+    const agentsInstallDirectory = join(agentsHome, MANAGED_AGENTS_DIRECTORY_NAME);
+    const hooksInstallDirectory = join(agentsHome, MANAGED_HOOKS_DIRECTORY_NAME);
+    const scriptsInstallDirectory = join(agentsHome, MANAGED_SCRIPTS_DIRECTORY_NAME);
+    const skillsLookupDirectory = join(managedRoot, MANAGED_SKILLS_DIRECTORY_NAME);
+    const agentsLookupDirectory = join(managedRoot, MANAGED_AGENTS_DIRECTORY_NAME);
+    const hooksLookupDirectory = join(managedRoot, MANAGED_HOOKS_DIRECTORY_NAME);
+    const scriptsLookupDirectory = join(managedRoot, MANAGED_SCRIPTS_DIRECTORY_NAME);
     return {
         managedRoot,
         source,
@@ -99,10 +160,25 @@ export function resolveInstallRoot(options = {}) {
         manifestFilePath: join(managedRoot, MANIFEST_FILE_NAME),
         mypyIniInstallPath,
         allDeclaredExternalPaths: [mypyIniInstallPath],
-        allDeclaredExternalDirectories: [codexRulesInstallDirectory, cursorInstallDirectory],
+        allDeclaredExternalDirectories: [
+            codexRulesInstallDirectory,
+            codexHooksInstallDirectory,
+            cursorInstallDirectory,
+            agentsHome,
+        ],
         codexRulesInstallDirectory,
         cursorInstallDirectory,
         cursorRulesInstallDirectory,
+        agentsHome,
+        skillsInstallDirectory,
+        agentsInstallDirectory,
+        skillsLookupDirectory,
+        agentsLookupDirectory,
+        hooksInstallDirectory,
+        scriptsInstallDirectory,
+        hooksLookupDirectory,
+        scriptsLookupDirectory,
+        codexHooksInstallDirectory,
     };
 }
 
@@ -131,8 +207,8 @@ export function isPathWithinManagedRoot(candidatePath, managedRoot) {
 
 /**
  * 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.
+ * home-directory `.mypy.ini`, a file under the Codex rules directory, a file
+ * under the Cursor rules directory, or a file under the agents home.
  *
  * @param {string} candidatePath
  * @param {InstallRootResolution} resolution

package/bin/resolve-package-managed-directory.mjs

@@ -0,0 +1,29 @@
+/**
+ * Resolve a managed content directory in a package source tree.
+ *
+ * This package keeps managed trees under `.agents/<name>/`. A dependency
+ * package may still keep those trees at `<package-root>/<name>/`. Callers pass
+ * the package root and the managed directory name; this helper returns the
+ * directory that exists.
+ */
+
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { PACKAGE_AGENTS_HOME_DIRECTORY_NAME } from './install-constants.mjs';
+
+/**
+ * @param {string} sourceRoot Package root that may hold `.agents/<name>` or `<name>`.
+ * @param {string} directoryName Managed directory name.
+ * @returns {string} Absolute source directory to copy from.
+ */
+export function resolvePackageManagedDirectory(sourceRoot, directoryName) {
+    const agentsHomeDirectory = join(
+        sourceRoot,
+        PACKAGE_AGENTS_HOME_DIRECTORY_NAME,
+        directoryName,
+    );
+    if (existsSync(agentsHomeDirectory)) {
+        return agentsHomeDirectory;
+    }
+    return join(sourceRoot, directoryName);
+}

package/bin/resolve-package-managed-directory.test.mjs

@@ -0,0 +1,97 @@
+/**
+ * Package-source layout: skills and agents live under `.agents`, and
+ * `.claude/skills` / `.claude/agents` are directory pointers to that home.
+ */
+
+import { test } from 'node:test';
+import { strict as assert } from 'node:assert';
+import {
+    existsSync,
+    lstatSync,
+    mkdirSync,
+    mkdtempSync,
+    realpathSync,
+    rmSync,
+    writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+    MANAGED_AGENTS_DIRECTORY_NAME,
+    MANAGED_SKILLS_DIRECTORY_NAME,
+    PACKAGE_AGENTS_HOME_DIRECTORY_NAME,
+} from './install-constants.mjs';
+import { resolvePackageManagedDirectory } from './resolve-package-managed-directory.mjs';
+
+const PACKAGE_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+const CANONICAL_SKILL_NAME = 'privacy-hygiene';
+const CANONICAL_AGENT_FILE_NAME = 'clean-coder.md';
+
+test('prefers the .agents tree when both layouts exist', () => {
+    const sourceRoot = mkdtempSync(join(tmpdir(), 'cdev-src-agents-'));
+    try {
+        const agentsHomeSkills = join(
+            sourceRoot, PACKAGE_AGENTS_HOME_DIRECTORY_NAME, MANAGED_SKILLS_DIRECTORY_NAME,
+        );
+        const packageRootSkills = join(sourceRoot, MANAGED_SKILLS_DIRECTORY_NAME);
+        mkdirSync(agentsHomeSkills, { recursive: true });
+        mkdirSync(packageRootSkills, { recursive: true });
+        writeFileSync(join(agentsHomeSkills, 'marker.txt'), 'canonical\n');
+        writeFileSync(join(packageRootSkills, 'marker.txt'), 'legacy\n');
+        assert.equal(
+            resolvePackageManagedDirectory(sourceRoot, MANAGED_SKILLS_DIRECTORY_NAME),
+            agentsHomeSkills,
+        );
+    } finally {
+        rmSync(sourceRoot, { recursive: true, force: true });
+    }
+});
+
+test('falls back to the package-root tree when .agents does not carry it', () => {
+    const sourceRoot = mkdtempSync(join(tmpdir(), 'cdev-src-legacy-'));
+    try {
+        const packageRootSkills = join(sourceRoot, MANAGED_SKILLS_DIRECTORY_NAME);
+        mkdirSync(packageRootSkills, { recursive: true });
+        assert.equal(
+            resolvePackageManagedDirectory(sourceRoot, MANAGED_SKILLS_DIRECTORY_NAME),
+            packageRootSkills,
+        );
+    } finally {
+        rmSync(sourceRoot, { recursive: true, force: true });
+    }
+});
+
+test('live package source keeps skills and agents under .agents with .claude pointers', () => {
+    const canonicalSkills = join(
+        PACKAGE_ROOT, PACKAGE_AGENTS_HOME_DIRECTORY_NAME, MANAGED_SKILLS_DIRECTORY_NAME,
+    );
+    const canonicalAgents = join(
+        PACKAGE_ROOT, PACKAGE_AGENTS_HOME_DIRECTORY_NAME, MANAGED_AGENTS_DIRECTORY_NAME,
+    );
+    const lookupSkills = join(PACKAGE_ROOT, '.claude', MANAGED_SKILLS_DIRECTORY_NAME);
+    const lookupAgents = join(PACKAGE_ROOT, '.claude', MANAGED_AGENTS_DIRECTORY_NAME);
+
+    assert.equal(
+        resolvePackageManagedDirectory(PACKAGE_ROOT, MANAGED_SKILLS_DIRECTORY_NAME),
+        canonicalSkills,
+    );
+    assert.equal(
+        resolvePackageManagedDirectory(PACKAGE_ROOT, MANAGED_AGENTS_DIRECTORY_NAME),
+        canonicalAgents,
+    );
+    assert.equal(
+        existsSync(join(canonicalSkills, CANONICAL_SKILL_NAME, 'SKILL.md')),
+        true,
+    );
+    assert.equal(
+        existsSync(join(canonicalAgents, CANONICAL_AGENT_FILE_NAME)),
+        true,
+    );
+    assert.equal(existsSync(join(PACKAGE_ROOT, MANAGED_SKILLS_DIRECTORY_NAME)), false);
+    assert.equal(existsSync(join(PACKAGE_ROOT, MANAGED_AGENTS_DIRECTORY_NAME)), false);
+    assert.equal(lstatSync(lookupSkills).isSymbolicLink(), true);
+    assert.equal(lstatSync(lookupAgents).isSymbolicLink(), true);
+    assert.equal(realpathSync(lookupSkills), realpathSync(canonicalSkills));
+    assert.equal(realpathSync(lookupAgents), realpathSync(canonicalAgents));
+});

package/commands/AGENTS.md

@@ -2,6 +2,8 @@
 
 Slash-command definitions installed into `~/.claude/commands/` by `bin/install.mjs`. Each `.md` file registers a `/command-name` the user can type in Claude Code. The file name (without `.md`) becomes the command name.
 
+Command bodies use `rules/asd-ste100-language.md` for user-facing word choice, sentence style, tone, punctuation, and prose form. Each command keeps its workflow contract.
+
 ## Command files
 
 | File | Command | What it does |

package/commands/sr-loop.md

@@ -7,6 +7,9 @@ Run the converging cleanup loop on the target: `$ARGUMENTS` (blank means the
 current branch's diff). Each phase invokes an existing skill with the Skill
 tool and repeats it until a pass returns zero new findings.
 
+Use `rules/asd-ste100-language.md` for user-facing wording. Keep the loop's
+cleanup, verification, commit, push, and finish-report fields.
+
 ## Phase A — loop /simplify
 
 1. Invoke the `simplify` skill on the target (the same review the user gets

package/docs/references/prose-style-enforcement.md

@@ -1,6 +1,6 @@
 # Prose-style enforcement
 
-Opinionated prose gates (heavy-word swaps, hedging, historical state phrasing, intent-only endings, hook prose-detector consistency) are **off by default**.
+Opinionated prose gates (hedging, historical state phrasing, intent-only endings, hook prose-detector consistency) are **off by default**.
 
 ## Opt-in
 
@@ -10,16 +10,12 @@ The flag is `PROSE_STYLE_ENFORCEMENT_ENABLED` in `hooks/blocking/config/prose_st
 
 ## Always on
 
-Structural AskUserQuestion lean-block validation in `plain_language_blocker` (chat detail, length caps on question blocks) stays active regardless of the flag. Code-rules and security blockers are out of scope for this switch.
+Structural AskUserQuestion lean-block validation in `ask_user_question_shape_blocker` (chat detail, length caps on question blocks) stays active regardless of the flag. Apply `rules/asd-ste100-language.md` for user-facing word choice and sentence style. Code-rules and security blockers are out of scope for this switch.
 
 ## Advisory precision measurement (OP-07B)
 
-When the flag is off, heavy-word and hedging hits still emit privacy-safe advisory candidates to `~/.claude/logs/prose-matcher-advisory.jsonl` (matcher id, surface, hashed context fingerprint, optional label). Classification (`keep` / `narrow` / `drop` / `advisory`) uses a labeled sample floor of 30 and precision floors 0.7 / 0.4. Matchers below the floor stay advisory. No matcher becomes hard-blocking from historical labels alone. See `hooks/observability/prose_matcher_advisory.py`.
+When the flag is off, hedging hits still emit privacy-safe advisory candidates to `~/.claude/logs/prose-matcher-advisory.jsonl` (matcher id, surface, hashed context fingerprint, optional label). Classification (`keep` / `narrow` / `drop` / `advisory`) uses a labeled sample floor of 30 and precision floors 0.7 / 0.4. Matchers below the floor stay advisory. See `hooks/observability/prose_matcher_advisory.py`.
 
 ## Explicit uncertainty (OP-07C)
 
 With enforcement on, a hedge word in a sentence that also labels the claim (`unverified`, `I don't know`, `no source for this claim`, …) passes. A bare hedge in a different sentence still blocks. Detail: `rules/hedging-claims.md`.
-
-## Plain-language advisory (OP-07D)
-
-Heavy-word matches never hard-deny a Write/Edit or AskUserQuestion. With enforcement on, the hook allows the call and returns a `systemMessage` that names everyday swaps for both AskUserQuestion and `.md` writes. Lean-block structure denials stay hard. Detail: `rules/plain-language.md`.

package/hooks/AGENTS.md

@@ -9,9 +9,6 @@ Python hook scripts wired into Claude Code's lifecycle via `settings.json`. Each
 | `advisory/` | Hooks that warn but do not block (`permissionDecision: "ask"`) |
 | `blocking/` | Hooks that deny tool calls when a rule is violated |
 | `blocking/config/` | Shared constants for blocking hooks |
-| `diagnostic/` | Hooks that record and extract hook-firing records into Neon |
-| `diagnostic/migrations/` | SQL migrations for the `hook_events` Neon schema |
-| `diagnostic/queries/` | Parameterized SQL queries for inspecting blocked commands |
 | `git-hooks/` | Native git hooks (`pre-commit`, `pre-push`, `post-commit`) installed via the git-hooks path |
 | `git-hooks/git_hooks_constants/` | Shared constants for the git-hook scripts |
 | `hooks_constants/` | Shared constant modules imported by multiple hooks across this tree (includes `pii_prevention_constants.py` for personal-data and secret scan patterns) |

package/hooks/blocking/AGENTS.md

@@ -74,7 +74,6 @@ The check modules it calls are the `code_rules_<concern>.py` files below.
 | `destructive_command_blocker.py` | PreToolUse (Bash/PowerShell) | Shell commands with destructive literals (`rm -rf`, `git reset --hard`, etc.) |
 | `docstring_rule_gate_count_blocker.py` | PreToolUse (Write/Edit/MultiEdit) | A stale spelled-out gate-validator count in `docstring-prose-matches-implementation.md` — the "N more gate validators" / "M gated slices" count drifting from the `check_docstring_*` validators the prose names |
 | `duplicate_rmtree_helper_blocker.py` | PreToolUse (Write/Edit) | A local re-definition of the Windows-safe rmtree helper trio (`_strip_read_only_and_retry`, `_force_remove_tree` / `force_rmtree`) in place of importing a shared helper |
-| `eli11_reply_enforcer.py` | Stop | Final replies breaking the `eli11-replies` shape — more than 6 bullet lines, more than 2 list lines over 20 words each, or multi-line instructions with no numbered step among the lead lines. Code fences, inline code, blockquotes, table rows, and link targets come off before the reply is judged. |
 | `env_var_table_code_drift_blocker.py` | PreToolUse (Write/Edit/MultiEdit) | A markdown env-var summary table row attributing an environment variable to a code file whose source never references that variable name |
 | `es_exe_path_rewriter.py` | PreToolUse | Rewrites paths referencing `.exe` under the Everything search path |
 | `fable_spawn_gate.py` | PreToolUse (Agent/Task) | An `Agent` or `Task` spawn whose prompt carries no `FABLE-SPAWN-AUTHORIZED` token and whose model field reads `fable` in any letter case — the bare alias, or a delimiter segment of a full model id, so `claude-fable-5` is denied too |
@@ -92,7 +91,6 @@ The check modules it calls are the `code_rules_<concern>.py` files below.
 | `pii_prevention_blocker.py` | PreToolUse (Write/Edit/MultiEdit/Bash/PowerShell/MCP GitHub) | Entry hook — content that carries high-confidence personal data or secrets (real emails, home-dir paths, private IPs, credential material) on write, durable GitHub posts, or staged commit paths; resolves the staged-commit repository from the command it gates (via `pii_prevention_blocker_parts`), not the session working directory |
 | `pii_scanner.py` | library | Pure text scanners shared by `pii_prevention_blocker.py` |
 | `piped_pytest_blocker.py` | PreToolUse (Bash) | A pytest run whose output feeds a pipe, where the pipeline reports the exit code of the command on the right |
-| `plain_language_blocker.py` | PreToolUse (Write/Edit/AskUserQuestion) | Heavy or jargon words in user-facing prose when `CLAUDE_PROSE_STYLE_ENFORCEMENT` is on (default off); AskUserQuestion lean-block structure stays always on |
 | `precommit_code_rules_gate.py` | PreToolUse (Bash) | Staged changes that fail the CODE_RULES gate at commit time |
 | `pytest_testpaths_orphan_blocker.py` | PreToolUse (Write/Edit/MultiEdit) | New `test_*.py` files created under a directory absent from a package's explicit pytest `testpaths` allowlist |
 | `question_to_user_enforcer.py` | Stop | User-directed questions not routed through `AskUserQuestion` |

package/hooks/blocking/ask_user_question_shape_blocker.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+"""PreToolUse hook that enforces AskUserQuestion field shape."""
+
+from __future__ import annotations
+
+import json
+import sys
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+
+_hooks_dir = str(Path(__file__).resolve().parent.parent)
+if _hooks_dir not in sys.path:
+    sys.path.insert(0, _hooks_dir)
+
+from hooks_constants.ask_user_question_shape import (  # noqa: E402
+    analyze_ask_user_question_shape,
+)
+from hooks_constants.ask_user_question_shape_constants import (  # noqa: E402
+    ASK_USER_QUESTION_TOOL_NAME,
+    LEAN_QUESTION_BLOCK_GUIDANCE,
+    LEAN_QUESTION_BLOCK_PREFIX,
+    LEAN_QUESTION_VIOLATION_SEPARATOR,
+    USER_FACING_LEAN_QUESTION_NOTICE,
+)
+from hooks_constants.hook_block_logger import log_hook_block  # noqa: E402
+
+
+def build_lean_block_reason(all_violations: Sequence[str]) -> str:
+    """Build a deny reason that names each field-shape violation."""
+    violation_list = LEAN_QUESTION_VIOLATION_SEPARATOR.join(all_violations)
+    return f"{LEAN_QUESTION_BLOCK_PREFIX}{violation_list}. {LEAN_QUESTION_BLOCK_GUIDANCE}"
+
+
+def evaluate(payload_by_key: Mapping[str, object]) -> str | None:
+    """Return a deny reason when an AskUserQuestion payload breaks field shape."""
+    tool_name = payload_by_key.get("tool_name", "")
+    tool_input = payload_by_key.get("tool_input", {})
+    if tool_name != ASK_USER_QUESTION_TOOL_NAME:
+        return None
+    if not isinstance(tool_input, Mapping):
+        return None
+    shape_result = analyze_ask_user_question_shape(tool_input)
+    if shape_result.is_lean:
+        return None
+    return build_lean_block_reason(shape_result.all_violations)
+
+
+def build_deny_payload(deny_reason: str) -> dict[str, object]:
+    """Build the standard PreToolUse deny payload for a shape violation."""
+    log_hook_block(
+        calling_hook_name="ask_user_question_shape_blocker.py",
+        hook_event="PreToolUse",
+        block_reason=deny_reason,
+    )
+    return {
+        "hookSpecificOutput": {
+            "hookEventName": "PreToolUse",
+            "permissionDecision": "deny",
+            "permissionDecisionReason": deny_reason,
+        },
+        "systemMessage": USER_FACING_LEAN_QUESTION_NOTICE,
+        "suppressOutput": True,
+    }
+
+
+def main() -> None:
+    """Read one PreToolUse payload and deny malformed question shape."""
+    try:
+        payload_by_key = json.load(sys.stdin)
+    except json.JSONDecodeError:
+        sys.exit(0)
+
+    if not isinstance(payload_by_key, dict):
+        sys.exit(0)
+    deny_reason = evaluate(payload_by_key)
+    if deny_reason is None:
+        sys.exit(0)
+    sys.stdout.write(json.dumps(build_deny_payload(deny_reason)))
+    sys.stdout.flush()
+
+
+if __name__ == "__main__":
+    main()

package/hooks/blocking/hedging_language_blocker.py

@@ -49,6 +49,7 @@ from observability.prose_matcher_advisory import emit_advisory_candidate  # noqa
 PLUGIN_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 RESEARCH_MODE_SKILL_SEARCH_PATHS = [
+    os.path.join(PLUGIN_ROOT, ".agents", "skills", "research-mode", "SKILL.md"),
     os.path.join(PLUGIN_ROOT, "skills", "research-mode", "SKILL.md"),
     os.path.join(os.path.expanduser("~"), ".claude", "skills", "research-mode", "SKILL.md"),
     os.path.join(os.path.expanduser("~"), ".claude", "plugins", "marketplaces", "claude-deep-research", "skills", "research-mode", "SKILL.md"),

package/hooks/blocking/orchestrator_refresh_reschedule_gate.py

@@ -25,6 +25,7 @@ if _hooks_dir not in sys.path:
 from hooks_constants.hook_block_logger import log_hook_block  # noqa: E402
 from hooks_constants.orchestrator_refresh_reschedule_gate_constants import (  # noqa: E402
     ALL_HOME_SKILLS_RELATIVE_PARTS,
+    ALL_PACKAGE_AGENTS_SKILL_SCRIPTS_RELATIVE_PARTS,
     ALL_SCHEDULE_TOOL_NAMES,
     ALL_SKILL_SCRIPTS_RELATIVE_PARTS,
     CALLING_HOOK_NAME,
@@ -51,14 +52,17 @@ def _candidate_skill_script_directories() -> list[Path]:
     """
     all_candidates: list[Path] = []
     plugin_root = os.environ.get(PLUGIN_ROOT_ENV_VAR)
+    relative_skill_script_layouts = (
+        ALL_PACKAGE_AGENTS_SKILL_SCRIPTS_RELATIVE_PARTS,
+        ALL_SKILL_SCRIPTS_RELATIVE_PARTS,
+    )
     if plugin_root:
-        all_candidates.append(
-            Path(plugin_root).joinpath(*ALL_SKILL_SCRIPTS_RELATIVE_PARTS)
-        )
+        plugin_root_path = Path(plugin_root)
+        for each_relative_parts in relative_skill_script_layouts:
+            all_candidates.append(plugin_root_path.joinpath(*each_relative_parts))
     package_hooks_parent = Path(__file__).resolve().parents[2]
-    all_candidates.append(
-        package_hooks_parent.joinpath(*ALL_SKILL_SCRIPTS_RELATIVE_PARTS)
-    )
+    for each_relative_parts in relative_skill_script_layouts:
+        all_candidates.append(package_hooks_parent.joinpath(*each_relative_parts))
     all_candidates.append(Path.home().joinpath(*ALL_HOME_SKILLS_RELATIVE_PARTS))
     return all_candidates
 

package/hooks/blocking/pre_tool_use_dispatcher.py

@@ -26,16 +26,6 @@ from pathlib import Path
 
 import _path_setup  # noqa: F401
 
-from plain_language_blocker import (
-    build_allow_advisory_payload as build_plain_language_allow_advisory_payload,
-)
-from plain_language_blocker import (
-    build_deny_payload as build_plain_language_deny_payload,
-)
-from plain_language_blocker import evaluate as evaluate_plain_language
-from plain_language_blocker import (
-    evaluate_with_advisory as evaluate_plain_language_with_advisory,
-)
 from state_description_blocker import (
     build_deny_payload as build_state_description_deny_payload,
 )
@@ -50,7 +40,6 @@ from hooks_constants.pre_tool_use_dispatcher_constants import (
     DENY_DECISION,
     EXIT_CODE_TWO_DENY_REASON,
     HOOK_EVENT_NAME,
-    PLAIN_LANGUAGE_BLOCKER_MODULE_NAME,
     REASON_JOIN_SEPARATOR,
     STATE_DESCRIPTION_BLOCKER_MODULE_NAME,
     SYSTEM_MESSAGE_JOIN_SEPARATOR,
@@ -77,7 +66,7 @@ class NativeHook:
             additionalContext, and suppressOutput).
         evaluate_with_advisory: Optional evaluator that returns
             ``(deny_reason, advisory_system_message)`` so allow-path notices
-            match the standalone hook (plain_language OP-07D).
+            match the standalone hook.
         build_allow_advisory_payload: Optional builder for an allow payload that
             carries the advisory systemMessage without denying.
     """
@@ -93,12 +82,6 @@ _native_hook_by_module_name: dict[str, NativeHook] = {
         evaluate=evaluate_state_description,
         build_deny_payload=build_state_description_deny_payload,
     ),
-    PLAIN_LANGUAGE_BLOCKER_MODULE_NAME: NativeHook(
-        evaluate=evaluate_plain_language,
-        build_deny_payload=build_plain_language_deny_payload,
-        evaluate_with_advisory=evaluate_plain_language_with_advisory,
-        build_allow_advisory_payload=build_plain_language_allow_advisory_payload,
-    ),
 }
 
 
@@ -504,7 +487,7 @@ def _emit_allow_decision(decision: DispatcherDecision) -> None:
     Matches the shape a standalone hosted hook emits when it auto-approves the
     write, so a write a hosted hook allows explicitly is auto-approved under the
     dispatcher rather than falling back to the default permission flow. When a
-    hook also carried an advisory systemMessage (plain-language heavy words),
+    hook also carried an advisory systemMessage,
     that notice rides on the allow payload without denying.
     """
     allow_payload: dict[str, object] = {

package/hooks/blocking/state_description_blocker.py

@@ -351,7 +351,7 @@ def build_deny_payload(deny_reason: str) -> dict[str, object]:
                 "only the current state. For example:\n"
                 '  BAD: "Uses X instead of Y"  →  GOOD: "Uses X"\n'
                 '  BAD: "Previously configured via Z"  →  GOOD: "Configured via Z"\n'
-                "See ~/.claude/rules/doc-prose-cuts.md for full rules."
+                "Apply ~/.claude/rules/asd-ste100-language.md for user-facing language."
             ),
         },
         "systemMessage": "Agent wrote comparative/historical language - describe current state only",