constraintloop 0.3.0__tar.gz → 0.4.1__tar.gz

{constraintloop-0.3.0 → constraintloop-0.4.1}/.gitignore

@@ -16,3 +16,6 @@ dist/
 .constraintloop/
 constraintloop.local.yml
 constraintloop.local.yaml
+.claude/settings.local.json
+.codex/hooks.json
+.gemini/settings.json

{constraintloop-0.3.0 → constraintloop-0.4.1}/CHANGELOG.md

@@ -5,6 +5,34 @@ Versioning, with the usual initial-development flexibility for `0.y.z`.
 
 ## [Unreleased]
 
+## [0.4.1] - 2026-09-04
+
+- Raise enforced statement coverage from 90% to 95% and branch coverage from
+  80% to 90%.
+- Add behavioral coverage for lifecycle CLI boundaries, hook configuration
+  failures, native evaluator entrypoints, timeout escalation, project
+  scaffolding, environment parsing, and contract validation.
+
+## [0.4.0] - 2026-09-04
+
+- Enforce finite command timeouts across complete POSIX process groups so
+  leaked Docker/TestContainers descendants cannot hold Stop gates open.
+- Add an explicit `push` phase and opt-in managed Git pre-push hook for heavy
+  integration gates while keeping frequent Stop checks fast.
+- Install Claude hooks in gitignored local settings, persist explicit uninstall
+  tombstones, and remove ConstraintLoop's own committed agent settings files.
+- Defer lifecycle evaluation for subagents and turns paused on background or
+  scheduled work.
+- Compact hook failure output to counts, failing checks, and high-signal error
+  lines while retaining full evidence for `constraintloop debug`.
+- Run commands and command evaluators from a stable project context with the
+  project root on `PYTHONPATH`.
+
+## [0.3.1] - 2026-08-31
+
+- Prevent recursive Claude Stop-hook invocations from repeatedly blocking completion.
+- Add actionable version-skew guidance when a hook runtime rejects unknown contract keys.
+
 ## [0.3.0] - 2026-08-18
 
 - Add native monotonic ratchet constraints with committed JSON baselines,

{constraintloop-0.3.0 → constraintloop-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: constraintloop
-Version: 0.3.0
+Version: 0.4.1
 Summary: Evidence-based completion gates for AI coding agents
 Project-URL: Homepage, https://github.com/mauhpr/constraintloop
 Project-URL: Documentation, https://github.com/mauhpr/constraintloop/tree/main/docs
@@ -123,6 +123,7 @@ uv tool install constraintloop
 
 constraintloop init
 constraintloop setup --adapter all
+# Or add --pre-push above to wire heavyweight push gates locally.
 constraintloop run
 constraintloop ci
 ```
@@ -137,7 +138,7 @@ If you intentionally run setup through `uvx`, generated hooks pin the current
 ConstraintLoop version. You can choose another persistent invocation with, for
 example, `constraintloop setup --hook-executable "pipx run constraintloop"`.
 
-The five commands above establish this flow:
+The five core commands above establish this flow:
 
 ```mermaid
 sequenceDiagram
@@ -147,7 +148,7 @@ sequenceDiagram
     participant T as Project tools
     U->>CL: init + review contract
     U->>CL: setup hooks
-    A->>CL: run change/stop phase
+    A->>CL: run change/stop/push phase
     CL->>T: execute ready constraints
     T-->>CL: exit codes, metrics, artifacts
     CL-->>A: pass, repair, wait, or escalate
@@ -160,18 +161,27 @@ sequenceDiagram
 version: 1
 settings:
   max_auto_retries: 2
+  hook_output_limit: 4096
 
 constraints:
   tests:
     kind: command
     command: [python, -m, pytest, -q]
-    phases: [stop, ci]
+    phases: [stop, push, ci]
     watch: ["src/**/*.py", "tests/**/*.py", pyproject.toml]
     retry:
       max_attempts: 3
       exit_codes: [1]
       delay_seconds: 2
 
+  integration_tests:
+    kind: command
+    command: [python, -m, pytest, -q, -m, integration]
+    phases: [push, ci]
+    watch: ["src/**/*.py", "tests/**/*.py", pyproject.toml]
+    needs: [tests]
+    timeout_seconds: 900
+
   coverage:
     kind: metric
     command: [python, -m, pytest, --cov, "--cov-report=json:coverage.json"]
@@ -266,16 +276,22 @@ advisory until their false-positive and false-negative rates are measured.
 | --- | --- | --- |
 | `change` | After a file-changing tool action | Fast syntax, formatting, or diff checks |
 | `stop` | When the agent attempts to finish | Tests, build checks, and advisory review |
+| `push` | Explicit local run or opt-in Git pre-push hook | Full integration and platform suites |
 | `ci` | Protected hosted workflow | Authoritative uncached and waiver-free verification |
 
 1. `SessionStart` tells the coding agent which required gates exist.
 2. The prompt hook records the user's goal as review evidence.
 3. Before tool execution, agent attempts to edit the contract or create a
    waiver are denied.
-4. After tool execution, `change` gates run and fresh results are injected.
+4. After a main-agent tool execution, `change` gates run and fresh results are
+   injected. Subagent tool and stop events are ignored because their working
+   tree may be intentionally transient.
 5. Before compaction, the completion policy is restated.
 6. At `Stop` / `AfterAgent`, required `stop` gates block completion. The agent
-   receives precise evidence and may repair the code a bounded number of times.
+   receives compact evidence and may repair the code a bounded number of times.
+   ConstraintLoop defers this evaluation while background tasks or scheduled
+   wakeups are active. Full retained output remains available through
+   `constraintloop debug ID`.
 7. Advisory failures require either passing fresh evidence or an explicit
    snapshot-bound explanation; delivery alone never counts as review.
 8. Repeated required failure stops autonomous repair and requests a human
@@ -285,6 +301,12 @@ advisory until their false-positive and false-negative rates are measured.
    is human.
 9. `constraintloop ci` reruns every CI gate without local evidence or waivers.
 
+Every command constraint has a finite timeout (300 seconds by default). On POSIX,
+timeout cleanup terminates the entire spawned process group so TestContainers,
+Docker clients, and other descendants cannot keep inherited output pipes open.
+Commands run from their configured project-contained `cwd`, with the selected
+project root prepended to `PYTHONPATH`.
+
 Evidence is keyed by the constraint definition and the bytes of every file
 matched by `watch`. A source change therefore makes old evidence and waivers
 stale without a mutable invalidation list. Local state lives under the
@@ -295,8 +317,12 @@ For stronger machine-local gates, create a gitignored
 `constraintloop.local.yml`. ConstraintLoop recursively merges mappings over the
 repository contract and rejects changes that could weaken committed gates.
 The authoritative `constraintloop ci` command ignores this overlay.
-`init` and `setup` add the overlay names and `.constraintloop/state/` to the
-selected project's `.gitignore`, and warn if state is already tracked.
+`init` and `setup` add local state, the uninstall tombstone, generated agent hook
+settings, and overlay names to the selected project's `.gitignore`, and warn if
+state is already tracked. Claude uses its dedicated
+`.claude/settings.local.json` path. Explicit uninstall records a local tombstone,
+so a checkout that restores old committed hook wiring does not silently
+reactivate ConstraintLoop; setup clears the tombstone.
 
 ### Verdicts and what they mean
 
@@ -313,11 +339,14 @@ selected project's `.gitignore`, and warn if state is already tracked.
 ## Commands
 
 - `constraintloop init` — generate a reviewable initial contract.
-- `constraintloop setup --adapter claude|codex|gemini|all` — merge hook entries
-  while preserving existing hooks.
+- `constraintloop setup --adapter claude|codex|gemini|all [--pre-push]` — merge
+  agent hook entries while preserving existing hooks; optionally install an
+  owned Git pre-push hook for `push` gates.
 - `constraintloop uninstall --adapter claude|codex|gemini|all` — remove only
-  ConstraintLoop hook entries while preserving unrelated settings.
-- `constraintloop run --phase change|stop` — run local gates with fresh caching.
+  ConstraintLoop hook entries while preserving unrelated settings; pass
+  `--pre-push` to remove an owned Git hook too.
+- `constraintloop run --phase change|stop|push` — run local gates with fresh
+  caching. Push gates do not honor local waivers.
 - `constraintloop ci` — authoritative, uncached, waiver-free run.
 - `constraintloop cycle NAME --json` — execute one journaled loop transition.
 - `constraintloop supervise NAME` — poll pending evidence under a recoverable
@@ -325,7 +354,7 @@ selected project's `.gitignore`, and warn if state is already tracked.
 - `constraintloop loop-prompt NAME --adapter claude|codex` — print the bounded
   native-agent repair protocol without launching an agent.
 - `constraintloop status` — inspect evidence without executing commands.
-- `constraintloop explain --phase change|stop|ci` — show why each constraint
+- `constraintloop explain --phase change|stop|push|ci` — show why each constraint
   runs or is skipped, including matched and changed watch paths, cache state,
   and dependency chains.
 - `constraintloop baseline update ID|--all` — initialize or strengthen native
@@ -381,7 +410,7 @@ responses become `uncertain`; a required rubric therefore fails closed.
 
 ## Compatibility boundary
 
-The supported v0.3 surfaces are the CLI and exit codes, configuration schema,
+The supported v0.4 surfaces are the CLI and exit codes, configuration schema,
 evaluator command protocol, native hook responses, and schema-versioned
 evidence and cycle JSON. Python submodules are internal during initial
 development and are not covered by semantic-versioning compatibility promises.
@@ -401,7 +430,8 @@ policy. ConstraintLoop records which contract ran, which inputs it covered, and
 whether the evidence is still fresh.
 
 **Why do some constraints run after every action?** Put only fast feedback in
-the `change` phase. Expensive tests and reviews belong in `stop` and `ci`.
+the `change` phase. Keep unit checks in `stop`; put heavyweight integration
+suites in `push` and `ci`.
 
 **Can I use Codex or Claude Code instead of an API evaluator?** Yes. The native
 evaluator adapter prefers the active supported CLI and remains read-only.

{constraintloop-0.3.0 → constraintloop-0.4.1}/README.md

@@ -80,6 +80,7 @@ uv tool install constraintloop
 
 constraintloop init
 constraintloop setup --adapter all
+# Or add --pre-push above to wire heavyweight push gates locally.
 constraintloop run
 constraintloop ci
 ```
@@ -94,7 +95,7 @@ If you intentionally run setup through `uvx`, generated hooks pin the current
 ConstraintLoop version. You can choose another persistent invocation with, for
 example, `constraintloop setup --hook-executable "pipx run constraintloop"`.
 
-The five commands above establish this flow:
+The five core commands above establish this flow:
 
 ```mermaid
 sequenceDiagram
@@ -104,7 +105,7 @@ sequenceDiagram
     participant T as Project tools
     U->>CL: init + review contract
     U->>CL: setup hooks
-    A->>CL: run change/stop phase
+    A->>CL: run change/stop/push phase
     CL->>T: execute ready constraints
     T-->>CL: exit codes, metrics, artifacts
     CL-->>A: pass, repair, wait, or escalate
@@ -117,18 +118,27 @@ sequenceDiagram
 version: 1
 settings:
   max_auto_retries: 2
+  hook_output_limit: 4096
 
 constraints:
   tests:
     kind: command
     command: [python, -m, pytest, -q]
-    phases: [stop, ci]
+    phases: [stop, push, ci]
     watch: ["src/**/*.py", "tests/**/*.py", pyproject.toml]
     retry:
       max_attempts: 3
       exit_codes: [1]
       delay_seconds: 2
 
+  integration_tests:
+    kind: command
+    command: [python, -m, pytest, -q, -m, integration]
+    phases: [push, ci]
+    watch: ["src/**/*.py", "tests/**/*.py", pyproject.toml]
+    needs: [tests]
+    timeout_seconds: 900
+
   coverage:
     kind: metric
     command: [python, -m, pytest, --cov, "--cov-report=json:coverage.json"]
@@ -223,16 +233,22 @@ advisory until their false-positive and false-negative rates are measured.
 | --- | --- | --- |
 | `change` | After a file-changing tool action | Fast syntax, formatting, or diff checks |
 | `stop` | When the agent attempts to finish | Tests, build checks, and advisory review |
+| `push` | Explicit local run or opt-in Git pre-push hook | Full integration and platform suites |
 | `ci` | Protected hosted workflow | Authoritative uncached and waiver-free verification |
 
 1. `SessionStart` tells the coding agent which required gates exist.
 2. The prompt hook records the user's goal as review evidence.
 3. Before tool execution, agent attempts to edit the contract or create a
    waiver are denied.
-4. After tool execution, `change` gates run and fresh results are injected.
+4. After a main-agent tool execution, `change` gates run and fresh results are
+   injected. Subagent tool and stop events are ignored because their working
+   tree may be intentionally transient.
 5. Before compaction, the completion policy is restated.
 6. At `Stop` / `AfterAgent`, required `stop` gates block completion. The agent
-   receives precise evidence and may repair the code a bounded number of times.
+   receives compact evidence and may repair the code a bounded number of times.
+   ConstraintLoop defers this evaluation while background tasks or scheduled
+   wakeups are active. Full retained output remains available through
+   `constraintloop debug ID`.
 7. Advisory failures require either passing fresh evidence or an explicit
    snapshot-bound explanation; delivery alone never counts as review.
 8. Repeated required failure stops autonomous repair and requests a human
@@ -242,6 +258,12 @@ advisory until their false-positive and false-negative rates are measured.
    is human.
 9. `constraintloop ci` reruns every CI gate without local evidence or waivers.
 
+Every command constraint has a finite timeout (300 seconds by default). On POSIX,
+timeout cleanup terminates the entire spawned process group so TestContainers,
+Docker clients, and other descendants cannot keep inherited output pipes open.
+Commands run from their configured project-contained `cwd`, with the selected
+project root prepended to `PYTHONPATH`.
+
 Evidence is keyed by the constraint definition and the bytes of every file
 matched by `watch`. A source change therefore makes old evidence and waivers
 stale without a mutable invalidation list. Local state lives under the
@@ -252,8 +274,12 @@ For stronger machine-local gates, create a gitignored
 `constraintloop.local.yml`. ConstraintLoop recursively merges mappings over the
 repository contract and rejects changes that could weaken committed gates.
 The authoritative `constraintloop ci` command ignores this overlay.
-`init` and `setup` add the overlay names and `.constraintloop/state/` to the
-selected project's `.gitignore`, and warn if state is already tracked.
+`init` and `setup` add local state, the uninstall tombstone, generated agent hook
+settings, and overlay names to the selected project's `.gitignore`, and warn if
+state is already tracked. Claude uses its dedicated
+`.claude/settings.local.json` path. Explicit uninstall records a local tombstone,
+so a checkout that restores old committed hook wiring does not silently
+reactivate ConstraintLoop; setup clears the tombstone.
 
 ### Verdicts and what they mean
 
@@ -270,11 +296,14 @@ selected project's `.gitignore`, and warn if state is already tracked.
 ## Commands
 
 - `constraintloop init` — generate a reviewable initial contract.
-- `constraintloop setup --adapter claude|codex|gemini|all` — merge hook entries
-  while preserving existing hooks.
+- `constraintloop setup --adapter claude|codex|gemini|all [--pre-push]` — merge
+  agent hook entries while preserving existing hooks; optionally install an
+  owned Git pre-push hook for `push` gates.
 - `constraintloop uninstall --adapter claude|codex|gemini|all` — remove only
-  ConstraintLoop hook entries while preserving unrelated settings.
-- `constraintloop run --phase change|stop` — run local gates with fresh caching.
+  ConstraintLoop hook entries while preserving unrelated settings; pass
+  `--pre-push` to remove an owned Git hook too.
+- `constraintloop run --phase change|stop|push` — run local gates with fresh
+  caching. Push gates do not honor local waivers.
 - `constraintloop ci` — authoritative, uncached, waiver-free run.
 - `constraintloop cycle NAME --json` — execute one journaled loop transition.
 - `constraintloop supervise NAME` — poll pending evidence under a recoverable
@@ -282,7 +311,7 @@ selected project's `.gitignore`, and warn if state is already tracked.
 - `constraintloop loop-prompt NAME --adapter claude|codex` — print the bounded
   native-agent repair protocol without launching an agent.
 - `constraintloop status` — inspect evidence without executing commands.
-- `constraintloop explain --phase change|stop|ci` — show why each constraint
+- `constraintloop explain --phase change|stop|push|ci` — show why each constraint
   runs or is skipped, including matched and changed watch paths, cache state,
   and dependency chains.
 - `constraintloop baseline update ID|--all` — initialize or strengthen native
@@ -338,7 +367,7 @@ responses become `uncertain`; a required rubric therefore fails closed.
 
 ## Compatibility boundary
 
-The supported v0.3 surfaces are the CLI and exit codes, configuration schema,
+The supported v0.4 surfaces are the CLI and exit codes, configuration schema,
 evaluator command protocol, native hook responses, and schema-versioned
 evidence and cycle JSON. Python submodules are internal during initial
 development and are not covered by semantic-versioning compatibility promises.
@@ -358,7 +387,8 @@ policy. ConstraintLoop records which contract ran, which inputs it covered, and
 whether the evidence is still fresh.
 
 **Why do some constraints run after every action?** Put only fast feedback in
-the `change` phase. Expensive tests and reviews belong in `stop` and `ci`.
+the `change` phase. Keep unit checks in `stop`; put heavyweight integration
+suites in `push` and `ci`.
 
 **Can I use Codex or Claude Code instead of an API evaluator?** Yes. The native
 evaluator adapter prefers the active supported CLI and remains read-only.

{constraintloop-0.3.0 → constraintloop-0.4.1}/docs/configuration.md

@@ -22,6 +22,7 @@ Settings default to:
 | `max_auto_retries` | 2 | 0–20 |
 | `concurrency` | 4 | 1–32 |
 | `evidence_output_limit` | 65536 | 1024–1048576 bytes |
+| `hook_output_limit` | 4096 | 512–32768 bytes |
 | `evaluation_bundle_limit` | 102400 | 4096–2097152 bytes |
 | `progress_interval_seconds` | 15 | 0.1–300 seconds |
 
@@ -37,7 +38,7 @@ authoritative `constraintloop ci` command ignores local overlays and always
 evaluates the committed repository contract.
 
 Every constraint supports `description`, `enforcement` (`required` or
-`advisory`), `phases` (`change`, `stop`, `ci`), `watch` globs, dependency IDs
+`advisory`), `phases` (`change`, `stop`, `push`, `ci`), `watch` globs, dependency IDs
 in `needs`, `timeout_seconds`, and `enabled`. Dependencies must exist and the
 graph must be acyclic.
 Identifiers may contain letters, numbers, dots, underscores, and hyphens.
@@ -63,13 +64,17 @@ retry:
 
 No retries occur when `retry` is absent. A configured policy retries only the
 listed exit codes and, when enabled, timeouts or process startup failures.
-Every attempt is capped by the constraint's normal timeout. Retry and periodic
+Every attempt is capped by the constraint's normal timeout, which defaults to
+300 seconds and is always finite. On POSIX, a timeout terminates the entire
+spawned process group, including descendants that inherited the command's output
+pipes. Retry and periodic
 running status lines are emitted during human-readable runs; `--json` remains a
 single machine-readable document. `timeout_seconds` bounds each attempt and,
 unless overridden, the complete retry sequence including delays. Timeout
 retries require an explicit `total_timeout_seconds` greater than the per-attempt
 timeout. This keeps the total bound visible while leaving enough budget for a
-second attempt.
+second attempt. Command and command-evaluator processes run from the selected
+project root by default, and ConstraintLoop prepends that root to `PYTHONPATH`.
 
 Metric constraints add `parser` and `threshold`. A parser has type `json` or
 `regex`, reads `stdout`, `stderr`, or a project-contained `file`, and selects a
@@ -133,4 +138,7 @@ state, and dependency chains without executing any gate. Human-readable final
 summaries label concrete policy failures as `constraint` and startup,
 prerequisite, or evaluation errors as `environment`; the same
 `failure_category` is retained in JSON evidence.
+Hook responses use `hook_output_limit` to retain failing test names and the first
+useful traceback line without injecting the complete test log. The unabridged
+retained tail remains available with `constraintloop debug CONSTRAINT`.
 See `docs/convergence-loops.md` for the cycle protocol and stable exit codes.

{constraintloop-0.3.0 → constraintloop-0.4.1}/docs/faq.md

@@ -24,10 +24,11 @@ They should have different purposes:
 | --- | --- |
 | `change` | Fast feedback after edits |
 | `stop` | Complete local evidence before the agent finishes |
+| `push` | Opt-in heavyweight local evidence before Git push |
 | `ci` | Independent, uncached, waiver-free verification |
 
-If full tests run after every edit, remove `change` from that constraint and
-keep it in `stop` and `ci`.
+If full tests run after every edit, remove `change` from that constraint. Keep
+fast unit tests in `stop`; put full integration suites in `push` and `ci`.
 
 ### What is the difference between a failure, uncertainty, and pending state?
 
@@ -134,9 +135,27 @@ trusted completion boundary.
 No. `constraintloop setup` merges owned hook entries and preserves unrelated
 configuration. In a monorepo, hooks retain the exact directory selected with
 `--project` instead of falling back to the Git root. `constraintloop uninstall`
-removes only owned entries. Review and trust newly installed Codex project hooks
+removes only owned entries and writes a gitignored local tombstone. Restoring an
+old committed settings file therefore cannot silently reactivate an explicitly
+uninstalled hook; running setup again clears the tombstone. Claude hooks are
+installed into `.claude/settings.local.json`, not the shareable
+`.claude/settings.json`. Review and trust newly installed Codex project hooks
 through `/hooks`.
 
+### Why did a Stop gate not run while background work was active?
+
+ConstraintLoop evaluates completion only for the main agent at an idle turn
+boundary. It ignores subagent hook events and defers Stop/AfterAgent while the
+hook payload reports background tasks or scheduled wakeups. Run
+`constraintloop run --phase stop` explicitly when you want an immediate check.
+
+### How do I keep integration tests off the frequent Stop gate?
+
+Assign them to `phases: [push, ci]`. Run them explicitly with
+`constraintloop run --phase push`, or install the local pre-push integration with
+`constraintloop setup --adapter all --pre-push`. Existing non-ConstraintLoop Git
+hooks are never overwritten.
+
 ### Why does a hook say `Missing option --project`?
 
 Regenerate the adapter configuration:
@@ -149,6 +168,22 @@ Generated commands include the resolved project argument. If the error remains,
 inspect the relevant `.claude`, `.codex`, or `.gemini` settings file for a stale
 manually copied command.
 
+### Why does a hook reject documented contract keys as extra inputs?
+
+The hook is running an older ConstraintLoop executable than the contract expects.
+Upgrade that installation, then regenerate the hook commands so they resolve to the
+same release:
+
+```bash
+constraintloop --version
+constraintloop setup --adapter all --project .
+```
+
+Current releases include their version and this recovery action when strict schema
+validation encounters unknown keys. Recursive Claude Stop-hook calls are allowed to
+finish after delivering the error once, so an invalid or version-skewed contract does
+not create a repeated Stop-hook loop.
+
 ## Loops
 
 ### Can I configure an unlimited repair loop?

{constraintloop-0.3.0 → constraintloop-0.4.1}/docs/recipes.md

@@ -9,8 +9,8 @@ silently from the strict schema.
 | Check | Recommended phase | Why |
 | --- | --- | --- |
 | Diff whitespace, syntax, targeted formatter | `change` | Fast enough to run after edits |
-| Unit tests, type checking, package build | `stop`, `ci` | Useful before completion, but noisy after every action |
-| Full integration or platform suite | `ci` | Hosted dependencies and longer runtime |
+| Unit tests, type checking, package build | `stop`, `push`, `ci` | Useful before completion and cheap enough to repeat before push |
+| Full integration or platform suite | `push`, `ci` | Local only when explicitly requested; authoritative in CI |
 | Design/security rubric | `stop`, optionally `ci` | Needs a complete patch and bounded evidence bundle |
 | Deployment or review status | `stop`, `ci` with pending code | External state may need polling |
 
@@ -28,8 +28,16 @@ constraintloop run --phase stop
 constraintloop ci
 ```
 
-The example separates fast syntax checking from session-end tests and coverage.
-Coverage depends on tests, so a test failure prevents a redundant coverage run.
+The example separates fast syntax checking from session-end tests, coverage, and
+push-only integration tests. Coverage and integration depend on unit tests, so a
+unit failure prevents redundant work. Install the optional local Git trigger with:
+
+```bash
+constraintloop setup --adapter all --pre-push
+```
+
+If another tool already owns `.git/hooks/pre-push`, ConstraintLoop refuses to
+replace it; add `constraintloop run --phase push` to that hook manually.
 
 ## Native Codex or Claude Code review
 

{constraintloop-0.3.0 → constraintloop-0.4.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "constraintloop"
-version = "0.3.0"
+version = "0.4.1"
 description = "Evidence-based completion gates for AI coding agents"
 readme = "README.md"
 license = "MIT"

{constraintloop-0.3.0 → constraintloop-0.4.1}/schema/constraintloop.schema.json

@@ -369,6 +369,13 @@
           "title": "Evidence Output Limit",
           "type": "integer"
         },
+        "hook_output_limit": {
+          "default": 4096,
+          "maximum": 32768,
+          "minimum": 512,
+          "title": "Hook Output Limit",
+          "type": "integer"
+        },
         "max_auto_retries": {
           "default": 2,
           "maximum": 20,
@@ -745,6 +752,7 @@
       "enum": [
         "change",
         "stop",
+        "push",
         "ci"
       ],
       "title": "Phase",

{constraintloop-0.3.0 → constraintloop-0.4.1}/scripts/check_coverage.py

@@ -6,8 +6,8 @@ import json
 import sys
 from pathlib import Path
 
-STATEMENT_FLOOR = 90.0
-BRANCH_FLOOR = 80.0
+STATEMENT_FLOOR = 95.0
+BRANCH_FLOOR = 90.0
 
 
 def main() -> int:

{constraintloop-0.3.0 → constraintloop-0.4.1}/src/constraintloop/__init__.py

@@ -1,7 +1,7 @@
 """ConstraintLoop package metadata.
 
-The v0.2 supported interfaces are the CLI and documented versioned protocols.
+The v0.4 supported interfaces are the CLI and documented versioned protocols.
 Python submodules are internal and may change during initial development.
 """
 
-__version__ = "0.3.0"
+__version__ = "0.4.1"

constraintloop-0.4.1/src/constraintloop/_process.py

@@ -0,0 +1,63 @@
+"""Bounded subprocess execution with descendant cleanup."""
+
+from __future__ import annotations
+
+import os
+import signal
+import subprocess
+from collections.abc import Mapping, Sequence
+from contextlib import suppress
+from pathlib import Path
+
+
+def run_bounded(
+    command: Sequence[str] | str,
+    *,
+    timeout: float,
+    cwd: Path | None = None,
+    env: Mapping[str, str] | None = None,
+    input_text: str | None = None,
+    shell: bool = False,
+) -> subprocess.CompletedProcess[str]:
+    """Run a command and tear down its whole process group after a timeout."""
+    process = subprocess.Popen(
+        command,
+        shell=shell,
+        cwd=cwd,
+        env=env,
+        stdin=subprocess.PIPE if input_text is not None else None,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        encoding="utf-8",
+        errors="replace",
+        start_new_session=os.name == "posix",
+    )
+    try:
+        stdout, stderr = process.communicate(input=input_text, timeout=timeout)
+    except subprocess.TimeoutExpired as exc:
+        stdout, stderr = _terminate_process_tree(process)
+        raise subprocess.TimeoutExpired(
+            command,
+            timeout,
+            output=stdout,
+            stderr=stderr,
+        ) from exc
+    return subprocess.CompletedProcess(command, process.returncode, stdout or "", stderr or "")
+
+
+def _terminate_process_tree(process: subprocess.Popen[str]) -> tuple[str, str]:
+    """Terminate the process group, escalating quickly when descendants ignore TERM."""
+    if os.name == "posix":
+        with suppress(ProcessLookupError):
+            os.killpg(process.pid, signal.SIGTERM)
+    else:
+        process.terminate()
+    try:
+        return process.communicate(timeout=0.5)
+    except subprocess.TimeoutExpired:
+        if os.name == "posix":
+            with suppress(ProcessLookupError):
+                os.killpg(process.pid, signal.SIGKILL)
+        else:
+            process.kill()
+        return process.communicate()