claude-dev-env 4.3.0 → 7.1.0

package/hooks/validators/test_run_all_validators_policy_lint.py

@@ -50,3 +50,39 @@ def test_validate_proposed_file_keeps_ruff_as_an_explicit_native_step(
     )
 
     assert "Ruff" in _result_names(all_results)
+
+
+def _mixed_newline_overlong_source() -> str:
+    all_line_endings = ("\r\n", "\n")
+    all_body_lines = "".join(
+        "    running_total = running_total + 1"
+        + all_line_endings[each_line_index % len(all_line_endings)]
+        for each_line_index in range(29)
+    )
+    return (
+        "def calculate_total(running_total: int) -> int:"
+        + all_line_endings[0]
+        + all_body_lines
+        + "    return running_total"
+        + all_line_endings[1]
+    )
+
+
+def test_validate_proposed_file_preserves_mixed_newline_diagnostics(
+    tmp_path: Path,
+) -> None:
+    all_results = run_all_validators.validate_proposed_file(
+        str(tmp_path / "probe.py"),
+        _mixed_newline_overlong_source(),
+        include_ruff=False,
+    )
+
+    code_quality_result = next(
+        each_result
+        for each_result in all_results
+        if each_result.name == "Code Quality"
+    )
+    assert code_quality_result.passed is False
+    assert "Function 'calculate_total' is 31 lines (max 30)" in (
+        code_quality_result.output
+    )

package/hooks/validators/test_security_checks.py

@@ -29,6 +29,30 @@ def connect():
     return password
 '''
 
+METADATA_SOURCE_FIXTURE = '''
+AUTHORIZATION_HEADER = "Authorization"
+TOKEN_KEY = "token"
+INSTALLATION_TOKEN_ENDPOINT_TEMPLATE = "/app/installations/{installation_id}/access_tokens"
+TOKEN_RESOURCE_NAME = "installation token"
+'''
+
+HEADER_SOURCE_FIXTURE = '''
+AUTHORIZATION_HEADER = "actualsecret"
+'''
+
+ERROR_SOURCE_FIXTURE = '''
+PASSWORD_ERROR = "my secret password"
+'''
+
+UNSAFE_KEY_METADATA_SOURCE_FIXTURES = (
+    '''
+secret_key = "secret"
+''',
+    '''
+password_key = "password"
+''',
+)
+
 GOOD_PARAMETERIZED_SQL = '''
 def get_user(user_id):
     cursor.execute("SELECT * FROM users WHERE id = %s", (user_id,))
@@ -76,6 +100,39 @@ class TestHardcodedSecrets:
         violations = check_hardcoded_secrets(tree, "test.py")
         assert len(violations) == 1
 
+    def test_secret_metadata_passes(self) -> None:
+        tree = ast.parse(METADATA_SOURCE_FIXTURE)
+        violations = check_hardcoded_secrets(tree, "test.py")
+        assert violations == []
+
+    def test_authorization_header_value_fails(self) -> None:
+        tree = ast.parse(HEADER_SOURCE_FIXTURE)
+        violations = check_hardcoded_secrets(tree, "test.py")
+        assert len(violations) == 1
+
+    def test_password_error_fails(self) -> None:
+        tree = ast.parse(ERROR_SOURCE_FIXTURE)
+        violations = check_hardcoded_secrets(tree, "test.py")
+        assert len(violations) == 1
+
+    @pytest.mark.parametrize("source_fixture", UNSAFE_KEY_METADATA_SOURCE_FIXTURES)
+    def test_sensitive_key_values_fail(self, source_fixture: str) -> None:
+        tree = ast.parse(source_fixture)
+        violations = check_hardcoded_secrets(tree, "test.py")
+        assert len(violations) == 1
+
+    @pytest.mark.parametrize(
+        "endpoint",
+        (
+            "/tokens/{token_id}?access_token=actualsecret",
+            "/tokens/{token_id}#actualsecret",
+        ),
+    )
+    def test_token_endpoint_credentials_fail(self, endpoint: str) -> None:
+        tree = ast.parse(f'TOKEN_ENDPOINT_TEMPLATE = "{endpoint}"')
+        violations = check_hardcoded_secrets(tree, "test.py")
+        assert len(violations) == 1
+
 
 class TestSqlInjection:
     def test_parameterized_query_passes(self) -> None:

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "4.3.0",
+    "version": "7.1.0",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {
@@ -9,7 +9,7 @@
         "cde": "bin/cde.mjs"
     },
     "scripts": {
-        "test": "node --test \"bin/*.test.mjs\" \".agents/skills/**/*.test.mjs\" \"tests/fresh-session/**/*.test.mjs\""
+        "test": "node --test \"bin/*.test.mjs\" \".agents/skills/**/*.test.mjs\" \"tests/fresh-session/**/*.test.mjs\" \"scripts/ci/*.test.mjs\""
     },
     "files": [
         "bin/",

package/rules/confirm-implementation-forks.md

@@ -5,3 +5,5 @@ At a material fork — two or more viable paths that change the deliverable's sc
 How to ask: plain language, one option per path with its tradeoff in the description, recommended path listed first and flagged "(Recommended)", hold edits to the forked area until the answer arrives.
 
 Not a fork (just proceed): trivially reversible internal-only choices, anything the codebase / stated goal / an existing rule already determines (see `verify-before-asking`), or a single viable path.
+
+When an option you offered names a repair and the answer leaves it undone, write it down before the turn moves on: a todo entry, a `spawn_task` chip, or a filed issue. An answer of "no preference" settles which path you take now. It leaves the repair you found still waiting.

package/rules/durable-post-artifacts.md

@@ -40,7 +40,8 @@ name does not form a path.
 
 ## Validation
 
-Run `.agents/skills/_shared/pr-loop/scripts/durable_post_lint.py` before the
+Resolve the active managed root (`CLAUDE_CONFIG_DIR` when set, `~/.claude`
+otherwise), then run `<managed-root>/scripts/durable_post_lint.py` before the
 server write. Pass the matching action and body file. Use `pr-create`,
 `pr-edit`, `pr-comment`, `pr-review`, `issue-create`, `issue-edit`,
 `issue-comment`, or `github-mcp-post`.

package/rules/git-workflow.md

@@ -17,15 +17,27 @@ User-level rule: applies to **every** git repo that uses GitHub with `gh`. Small
 
 **ALWAYS create PRs as DRAFT:** Use `gh pr create --draft` for ALL PRs
 
+**A release bot's PR body is machine input. Leave it alone.** Release automation reads
+back the body of its own merged pull request to decide it owns that merge. Rewriting the
+body, or trimming its header or footer, makes the bot treat the merge as somebody else's
+work: it cuts no tag, the publish job skips, and it opens one more release pull request on
+the next run. The merge stays in the repository. No tag is cut and the package never publishes.
+
+Spot one by its head branch, which starts `release-please--branches--`, or by a body that
+opens with the bot's own marker line. The description rules in this file, the
+`pr-description-writer` agent, and the house wording style all step aside for it. The
+failure signature in the release job log reads
+`could not parse pull request body as a release PR`.
+
 Use the `pr-description-writer` agent before creating a pull request or
 rewriting its full description. Publish its title and body file through
-`.agents/skills/pull-request/scripts/pull_request.py`. The
-`pr-title-description` skill may review the writer's output but cannot replace
-the required writer.
+`.agents/skills/pull-request/scripts/pull_request.py`.
 
-Run `_shared/pr-loop/scripts/durable_post_lint.py` before any pull request,
-issue, or GitHub MCP post. The linter checks the action-specific title, body,
-and volatile-path rules before credential lookup or network access.
+Resolve the active managed root (`CLAUDE_CONFIG_DIR` when set, `~/.claude`
+otherwise), then run `<managed-root>/scripts/durable_post_lint.py` before any
+pull request, issue, or GitHub MCP post. The linter checks the action-specific
+title, body, and volatile-path rules before credential lookup or network
+access.
 
 Use `.agents/skills/pull-request/scripts/recover_legacy_author.py
 <exact-state-file> --confirm-inactive` only for one explicitly selected legacy

package/rules/pstack-host-mapping.md

@@ -0,0 +1,48 @@
+# Pstack host mapping
+
+Pstack skills ship with one host's tool names and paths written into their steps. The
+active host supplies the real ones. Read a pstack step for the shape of the work, and take
+the tool name, the skill home, and the transcript location from the host you run on.
+
+[`pstack-models.md`](pstack-models.md) covers the model choice for each role. This rule
+covers everything else a pstack step names.
+
+## What each host supplies
+
+| A pstack step names | Take from the host |
+|---|---|
+| A subagent tool | The native subagent tool this session exposes, with its own agent-type field |
+| A skills directory | The skills home this host reads |
+| A transcript directory | The session transcript location this host writes |
+| A model identifier | The identifiers the native subagent tool accepts today |
+
+A pstack step that names one host's directory means "the matching directory here". Resolve
+it before the search, and search only inside the active workspace.
+
+## The final message is the whole report
+
+On a host where a subagent returns one message to its parent, that message is all the
+parent receives. Working notes, tool output, and text the child printed along the way do
+not travel.
+
+Every pstack prompt that asks a child for a list, a set of findings, or a verdict also
+asks for the whole thing, word for word, in the final message. A prompt without that line
+gets back a summary such as "findings reported above", and the findings are gone. The
+parent then reruns the child, which costs the full run a second time.
+
+## Panel spawns
+
+Panel size and model diversity follow `pstack-models.md`. Two host limits shape a spawn
+beyond that:
+
+- A spawn gate can refuse a model tier. Read the denial, take the tier it names as
+  allowed, and spawn again.
+- A host may accept fewer distinct models than a panel asks for. A panel that requires
+  distinct models stops; a panel that treats diversity as optional runs with repeats.
+
+## Editing pstack
+
+Pstack installs as a plugin. A plugin update overwrites its files, so an edit inside a
+pstack skill lasts until the next update. Durable changes belong in a rule beside this
+one. The installer copies this package's rules into the managed rules directory and
+generates the Cursor copy from the same source.

package/rules/vault-context.md

@@ -1,7 +1,5 @@
-# Obsidian Vault Context
+# Obsidian vault context
 
-An Obsidian vault holds session reports (`sessions/`), decisions (`decisions/`), and research (`Research/`) across projects, reached through the obsidian MCP tools.
+An Obsidian vault holds session reports (`sessions/`), decisions (`decisions/`), and research (`Research/`) across projects.
 
-Before substantive project work, search the vault for prior sessions and decisions on the current project through the `recall` skill — by `project` frontmatter first, then by keyword. Search again when touching a component with known history, or when a task might repeat or reverse a prior decision.
-
-At the end of a substantive session, offer the `session-log` skill; it owns the report format, the `vault_context_retrieved` and `session_id` frontmatter, and the closing `/rename` hand-off.
+Before project work, search the vault with the obsidian MCP tools. Search by `project` frontmatter first, then by keyword. Search again when a component has known history, or when a task might repeat or reverse a prior decision.

package/rules/verify-runtime-state.md

@@ -8,6 +8,10 @@ A verdict that a component is fine or not the cause rests on live evidence gathe
 
 Gather the probe before you write the verdict. When the probe contradicts the code (the code looks right but the port refuses the connection), report the live result and treat the component as suspect.
 
+A status field is a report, not the effect. An exit code, a green pipeline run, and a task result all say the work finished. They do not say the work happened. Read the thing the work was meant to make.
+
+Some evidence lasts only a moment. When a user shows you a failure, read the source they already hold: the terminal itself, and any log file the error names. A fresh probe minutes later measures a different moment, and a system that healed in between hides the failure you were asked about.
+
 ## Grounding checklist
 
 Before stating a runtime claim, gather the matching live signal:
@@ -20,6 +24,9 @@ Before stating a runtime claim, gather the matching live signal:
 | The process is running | List processes and match the name or PID. |
 | The change took effect | Drive the flow and watch the new behavior. |
 | The dependency is reachable | Send one real request and read the response. |
+| The release or deploy shipped | Read what it makes: the tag, the published version, the file on disk. |
+| The pipeline did the work | Read each job's own result. A run reports success while a job inside it is skipped. |
+| The automation works | Drive the branch that matters. A green run of the do-nothing branch proves nothing. |
 
 Only after a live signal backs the claim do you state it.
 

package/scripts/audit-hooks-cli.mjs

@@ -11,6 +11,7 @@ function parseArguments(argv) {
     homeDirectory: null,
     includeInstalled: false,
     outputPath: null,
+    requireNonblocking: false,
     repositoryRoot: path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../.."),
   };
   for (let offset = 0; offset < argv.length; offset += 1) {
@@ -20,6 +21,7 @@ function parseArguments(argv) {
     else if (argument === "--format") options.format = argv[++offset];
     else if (argument === "--home") options.homeDirectory = argv[++offset];
     else if (argument === "--output") options.outputPath = argv[++offset];
+    else if (argument === "--require-nonblocking") options.requireNonblocking = true;
     else if (argument === "--repository-root") options.repositoryRoot = argv[++offset];
     else throw new Error(`unknown argument ${argument}`);
   }
@@ -37,6 +39,9 @@ function renderText(report) {
     `installed Claude direct: ${summary.claudeDirectCount}`,
     `installed Codex direct: ${summary.codexDirectCount}`,
     `active native Git hooks: ${summary.gitHookCount}`,
+    `known native Git hooks: ${summary.knownGitHookCount}`,
+    `registration eligibility: ${report.registrationEligibility.status}`,
+    "runtime proof: separate verification required",
     `findings: ${summary.findingCount}`,
   ].join("\n");
 }

package/scripts/audit-hooks.mjs

@@ -3,7 +3,8 @@ import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
 
-const expectedCounts = Object.freeze({ direct: 32, dispatchers: 5, hosted: 43 });
+import { KNOWN_GIT_HOOK_NAMES } from "../bin/git_hooks_installer.mjs";
+
 const dispatcherSpecs = Object.freeze([
   ["script:blocking/pre_tool_use_dispatcher.py", "hooks_constants/pre_tool_use_dispatcher_constants.py", "ALL_HOSTED_HOOK_ENTRIES"],
   ["script:blocking/bash_pre_tool_use_dispatcher.py", "hooks_constants/bash_pre_tool_use_dispatcher_constants.py", "ALL_BASH_HOSTED_HOOK_ENTRIES"],
@@ -19,6 +20,8 @@ const lifecycleNames = new Set([
   "move_to_explicit_command",
   "move_to_linter",
 ]);
+const nonblockingLifecycle = "keep_nonblocking_automation";
+const blockingGitEvents = new Set(["pre-commit", "pre-push"]);
 
 function normalizeMatcher(rawMatcher) {
   return typeof rawMatcher === "string" && rawMatcher
@@ -269,6 +272,55 @@ function lifecycleFindings(records, lifecycle) {
   ];
 }
 
+function nonblockingFindings(records, lifecycle) {
+  const lifecycleByTarget = new Map(
+    lifecycle.map(({ target, lifecycle: lifecycleName }) => [target, lifecycleName]),
+  );
+  const uniqueTargets = [...new Set(records.map(({ target }) => target))];
+  const lifecycleMismatches = uniqueTargets
+    .filter((target) => !target.startsWith("git:") && lifecycleByTarget.has(target))
+    .filter((target) => lifecycleByTarget.get(target) !== nonblockingLifecycle)
+    .map((target) => ({
+      code: "NONBLOCKING_LIFECYCLE_MISMATCH",
+      message: "The registration is not eligible for nonblocking automation.",
+      scope: "catalog",
+      severity: "error",
+      target,
+    }));
+  const blockingGitFindings = records
+    .filter(({ event, scope }) => scope === "git" && blockingGitEvents.has(event))
+    .map(({ target }) => ({
+      code: "NATIVE_GIT_BLOCKING_HOOK",
+      message: "A native Git blocking hook remains active.",
+      scope: "git",
+      severity: "error",
+      target,
+    }));
+  return [...lifecycleMismatches, ...blockingGitFindings];
+}
+
+function registrationEligibility(records, lifecycle, isRequired) {
+  if (!isRequired) {
+    return { status: "not_checked", runtimeProof: "not_assessed" };
+  }
+  const lifecycleByTarget = new Map(
+    lifecycle.map(({ target, lifecycle: lifecycleName }) => [target, lifecycleName]),
+  );
+  const uniqueTargets = [...new Set(records.map(({ target }) => target))];
+  const hasUnclassifiedTarget = uniqueTargets.some((target) => !lifecycleByTarget.has(target));
+  const hasIneligibleTarget = uniqueTargets.some(
+    (target) => lifecycleByTarget.get(target) && lifecycleByTarget.get(target) !== nonblockingLifecycle,
+  );
+  const hasBlockingGitHook = records.some(
+    ({ event, scope }) => scope === "git" && blockingGitEvents.has(event),
+  );
+  const isEligible = !hasUnclassifiedTarget && !hasIneligibleTarget && !hasBlockingGitHook;
+  return {
+    status: isEligible ? "eligible" : "ineligible",
+    runtimeProof: "not_assessed",
+  };
+}
+
 function readInstalled(configPath, hooksRoot, scope) {
   if (!existsSync(configPath)) return { findings: [], logical: [], records: [] };
   const records = readDirect(configPath, scope);
@@ -295,7 +347,7 @@ function activeGitHooks(repositoryRoot) {
   const hooksPath = gitQuery.stdout?.trim();
   if (!hooksPath) return [];
   const hooksRoot = path.isAbsolute(hooksPath) ? hooksPath : path.resolve(repositoryRoot, hooksPath);
-  return ["pre-commit", "pre-push", "post-commit"]
+  return KNOWN_GIT_HOOK_NAMES
     .filter((name) => existsSync(path.join(hooksRoot, name)))
     .map((name, ordinal) => ({
       event: name,
@@ -308,17 +360,16 @@ function activeGitHooks(repositoryRoot) {
     }));
 }
 
-function countFindings(directCount, dispatcherCount, hostedCount) {
-  const actual = { direct: directCount, dispatchers: dispatcherCount, hosted: hostedCount };
-  return Object.entries(expectedCounts)
-    .filter(([name, expected]) => actual[name] !== expected)
-    .map(([name, expected]) => ({
-      code: `${name.toUpperCase()}_COUNT_DRIFT`,
-      message: `Expected ${expected} entries and found ${actual[name]}.`,
-      scope: "canonical",
-      severity: "error",
-      target: null,
-    }));
+function knownGitHooks() {
+  return KNOWN_GIT_HOOK_NAMES.map((event, ordinal) => ({
+    event,
+    matcher: "*",
+    ordinal,
+    role: "native",
+    scope: "git",
+    target: `git:${event}`,
+    timeoutSeconds: null,
+  }));
 }
 
 export function auditHooks(options) {
@@ -327,16 +378,18 @@ export function auditHooks(options) {
   const direct = readDirect(path.join(hooksRoot, "hooks.json"), "canonical");
   const hosted = expandHosted(direct, hooksRoot);
   const logical = logicalRecords(direct, hosted);
+  const knownGit = knownGitHooks();
   const lifecycle = readLifecycle(options.catalogPath);
   const dispatcherCount = direct.filter(({ role }) => role === "dispatcher").length;
   const installed = options.includeInstalled
     ? installedAudit(options.homeDirectory ?? homedir(), repositoryRoot, logical)
     : { claudeCount: 0, codexCount: 0, findings: [], git: [], logical: [], records: [] };
   const allLogical = [...logical, ...installed.logical, ...installed.git];
+  const isNonblockingRequired = options.requireNonblocking === true;
   const findings = [
-    ...countFindings(direct.length, dispatcherCount, hosted.length),
     ...duplicateFindings(logical, "canonical"),
-    ...(options.catalogPath ? lifecycleFindings(allLogical, lifecycle) : []),
+    ...(options.catalogPath || isNonblockingRequired ? lifecycleFindings(allLogical, lifecycle) : []),
+    ...(isNonblockingRequired ? nonblockingFindings(allLogical, lifecycle) : []),
     ...installed.findings,
   ].sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)));
   const targets = new Set(allLogical.map(({ target }) => target));
@@ -348,6 +401,7 @@ export function auditHooks(options) {
     installedRegistrations: installed.records.sort(recordSort),
     installedLogicalRegistrations: installed.logical.sort(recordSort),
     gitRegistrations: installed.git,
+    knownGitRegistrations: knownGit,
     lifecycle,
     logicalRegistrations: logical,
     schemaVersion: 1,
@@ -359,13 +413,15 @@ export function auditHooks(options) {
       effectiveCount: hosted.length,
       findingCount: findings.length,
       gitHookCount: installed.git.length,
+      knownGitHookCount: knownGit.length,
       lifecycleCount: lifecycle.length,
       logicalAssociationCount: logical.length,
-      unclassifiedCount: options.catalogPath
+      unclassifiedCount: options.catalogPath || isNonblockingRequired
         ? [...targets].filter((target) => !classified.has(target)).length
         : 0,
       uniqueTargetCount: targets.size,
     },
+    registrationEligibility: registrationEligibility(allLogical, lifecycle, isNonblockingRequired),
   };
 }
 

package/scripts/automatic_advisory/__init__.py

@@ -0,0 +1 @@
+"""Automatic local verification for explicitly registered pull requests."""

package/scripts/automatic_advisory/checkout.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+from .config.constants import (
+    ALL_GIT_HEAD_ARGUMENTS,
+    ALL_GIT_STATUS_ARGUMENTS,
+    GIT_BASE_REF_TEMPLATE,
+    GIT_EXECUTABLE,
+)
+from .model import AdvisoryRegistration, LocalCheckout
+from .window_flags import hidden_window_creation_flags
+
+
+def read_local_checkout(checkout_path: Path) -> LocalCheckout:
+    """Read the current commit and clean status for one checkout.
+
+    Args:
+        checkout_path: Git working tree to inspect.
+
+    Returns:
+        Commit and clean status, with no commit when Git cannot inspect it.
+    """
+    try:
+        head_process = _run_git_command(ALL_GIT_HEAD_ARGUMENTS, checkout_path)
+        status_process = _run_git_command(ALL_GIT_STATUS_ARGUMENTS, checkout_path)
+    except OSError:
+        return LocalCheckout(None, False)
+    head_sha = head_process.stdout.strip() if head_process.returncode == 0 else None
+    return LocalCheckout(
+        head_sha,
+        status_process.returncode == 0 and not status_process.stdout,
+    )
+
+
+def _run_git_command(
+    all_arguments: tuple[str, ...], checkout_path: Path
+) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        (GIT_EXECUTABLE, *all_arguments),
+        cwd=checkout_path,
+        capture_output=True,
+        check=False,
+        text=True,
+        creationflags=hidden_window_creation_flags(),
+    )
+
+
+def dedicated_base_ref(registration: AdvisoryRegistration) -> str:
+    return GIT_BASE_REF_TEMPLATE.format(pull_request=registration.pull_request_number)