agent-lifecycle-kit 1.77.0__tar.gz → 1.78.0__tar.gz

{agent_lifecycle_kit-1.77.0/src/agent_lifecycle_kit.egg-info → agent_lifecycle_kit-1.78.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-lifecycle-kit
-Version: 1.77.0
+Version: 1.78.0
 Summary: Provider-neutral lifecycle control layer that helps coding agents plan, execute, validate, and prove software tasks to completion.
 Author: Agent Lifecycle Kit contributors
 License: Apache-2.0
@@ -43,7 +43,7 @@ ALK provides a verifiable finish for external-agent work with proportionate cont
 ## Quick start
 Start with [install ALK and make the first run](docs/guides/install-and-first-run.md).
 
-It includes macOS, Linux and Windows instructions, Python 3.11-3.14, [PyPI](https://pypi.org/project/agent-lifecycle-kit/) installation with `python -m pip install agent-lifecycle-kit==1.77.0`, and common `agent-lifecycle version` errors.
+It includes macOS, Linux and Windows instructions, Python 3.11-3.14, [PyPI](https://pypi.org/project/agent-lifecycle-kit/) installation with `python -m pip install agent-lifecycle-kit==1.78.0`, and common `agent-lifecycle version` errors.
 
 For a quick start, run:
 
@@ -80,7 +80,7 @@ agent-lifecycle start --adapter <adapter-id> --file task.md
   composes risk, model class, packet size, review and resource limits.
 - Usage visibility: tokens, time, resource counters and structured execution records without sensitive data are native; monetary cost is optional and only used when a metered host reports it.
 - Project-specific workflow settings: ALK can discover and validate uncommitted local defaults, or apply a built-in workflow preset for a common route, while the frozen plan remains authoritative.
-- Reproducible Python maintenance: pinned development-only Ruff, mypy and coverage checks, a non-growing quality ratchet, stable redacted CLI errors, installed package resources and an explicit documented Python API.
+- Reproducible Python maintenance: pinned development-only Ruff, mypy and coverage checks, a non-growing quality ratchet, stable redacted CLI errors, installed package resources, an explicit documented Python API, and bounded performance controls that preserve security and evidence rules.
 - Project principles and plan deltas keep long-running work understandable: principles provide bounded defaults, while a digest-bound delta shows which plan authority changed and whether review and a new lock are required. CI also checks an acyclic module/package graph, layer direction and source-size limits; adapter inspection uses bounded literal profiles and fails closed without executing adapter code.
 - Read-only progress and managed sessions: host UIs can show lifecycle state,
   attested tokens and Git-style change counters; `start` accepts task text,
@@ -195,7 +195,7 @@ Adapter installation and support-level details live in [Adapter install](docs/ad
 - Start: [English documentation](docs/README.md), [Русская документация](docs/ru/README.md), [Install](docs/guides/install-and-first-run.md), [Quickstart](docs/guides/quickstart.md), [Beginner and advanced workflows](docs/guides/beginner-and-advanced-workflows.md), [Commands by task](docs/guides/commands-by-task.md), [Research workflow](docs/guides/research-workflow.md), [Lifecycle task scenarios](docs/guides/lifecycle-cookbook.md), and [Code review workflows](docs/guides/code-review-workflows.md).
 - Planning and adapters: [Issue to specification drafts](docs/guides/issue-to-spec.md), [Adapter install](docs/adapters/install.md), and [Adapter support matrix](docs/adapters/support-matrix.md).
 - Reference: [System architecture](docs/architecture/system-architecture.md), [workflow customization and execution controls](docs/reference/workflow-customization.md), [execution strategy](docs/reference/execution-strategy.md), [CLI reference](docs/reference/cli.md), [Research evidence](docs/reference/research-evidence.md), [Source of truth](docs/reference/source-of-truth.md), [Managed lifecycle runner](docs/reference/managed-lifecycle-runner.md), [Managed adapter sessions](docs/reference/managed-adapter-sessions.md), [Portable Agent Plugins](docs/reference/agent-plugins.md), [Plugin publication](docs/reference/plugin-publication.md), [Implementation audit](docs/reference/implementation-audit.md), [Plan completeness](docs/reference/plan-completeness.md), [Public contracts](docs/reference/public-contracts.md), and [Readiness diagnostics](docs/reference/readiness-diagnostics.md).
-- Quality and resources: [Reference-task evaluation](docs/reference/reference-task-evaluation.md), [model routing](docs/reference/model-routing.md), [quality-cost learning](docs/reference/quality-cost-learning.md), [lifecycle cost accounting](docs/reference/lifecycle-cost.md), [host-local token accounting](docs/reference/host-local-token-accounting.md), [process execution observability](docs/reference/process-execution-observability.md), [Usage export](docs/reference/usage-export.md), and [Evidence integrity](docs/reference/evidence-integrity.md).
+- Quality and resources: [Reference-task evaluation](docs/reference/reference-task-evaluation.md), [model routing](docs/reference/model-routing.md), [quality-cost learning](docs/reference/quality-cost-learning.md), [performance and resource budgets](docs/reference/performance-and-resource-budgets.md), [lifecycle cost accounting](docs/reference/lifecycle-cost.md), [host-local token accounting](docs/reference/host-local-token-accounting.md), [process execution observability](docs/reference/process-execution-observability.md), [Usage export](docs/reference/usage-export.md), and [Evidence integrity](docs/reference/evidence-integrity.md).
 - Profiles and operations: [Project workflow presets](docs/reference/workflow-presets.md), [Project workflow profile](docs/reference/project-workflow-profile.md), [Read-only status views](docs/reference/read-only-status-view.md), [Adapter progress bridge](docs/reference/automatic-progress-bridge.md), [Sandbox boundaries](docs/reference/sandbox-boundaries.md), [Import mappers](docs/reference/import-mappers.md), [Episode retrieval](docs/reference/episode-retrieval.md), [Runner recovery](docs/reference/runner-recovery.md), [Cross-check profile](docs/reference/cross-check-profile.md), [Review Mesh](docs/reference/review-mesh.md), [Bug Forensics profile](docs/reference/bug-forensics.md), and [Bug Forensics context budget](docs/reference/bug-forensics-context-budget.md).
 - Release assets: [Task templates](templates/tasks/README.md), [Neutrality scanning](docs/reference/neutrality.md), and [Release security](docs/security/release-security.md).
 

{agent_lifecycle_kit-1.77.0 → agent_lifecycle_kit-1.78.0}/README.md

@@ -21,7 +21,7 @@ ALK provides a verifiable finish for external-agent work with proportionate cont
 ## Quick start
 Start with [install ALK and make the first run](docs/guides/install-and-first-run.md).
 
-It includes macOS, Linux and Windows instructions, Python 3.11-3.14, [PyPI](https://pypi.org/project/agent-lifecycle-kit/) installation with `python -m pip install agent-lifecycle-kit==1.77.0`, and common `agent-lifecycle version` errors.
+It includes macOS, Linux and Windows instructions, Python 3.11-3.14, [PyPI](https://pypi.org/project/agent-lifecycle-kit/) installation with `python -m pip install agent-lifecycle-kit==1.78.0`, and common `agent-lifecycle version` errors.
 
 For a quick start, run:
 
@@ -58,7 +58,7 @@ agent-lifecycle start --adapter <adapter-id> --file task.md
   composes risk, model class, packet size, review and resource limits.
 - Usage visibility: tokens, time, resource counters and structured execution records without sensitive data are native; monetary cost is optional and only used when a metered host reports it.
 - Project-specific workflow settings: ALK can discover and validate uncommitted local defaults, or apply a built-in workflow preset for a common route, while the frozen plan remains authoritative.
-- Reproducible Python maintenance: pinned development-only Ruff, mypy and coverage checks, a non-growing quality ratchet, stable redacted CLI errors, installed package resources and an explicit documented Python API.
+- Reproducible Python maintenance: pinned development-only Ruff, mypy and coverage checks, a non-growing quality ratchet, stable redacted CLI errors, installed package resources, an explicit documented Python API, and bounded performance controls that preserve security and evidence rules.
 - Project principles and plan deltas keep long-running work understandable: principles provide bounded defaults, while a digest-bound delta shows which plan authority changed and whether review and a new lock are required. CI also checks an acyclic module/package graph, layer direction and source-size limits; adapter inspection uses bounded literal profiles and fails closed without executing adapter code.
 - Read-only progress and managed sessions: host UIs can show lifecycle state,
   attested tokens and Git-style change counters; `start` accepts task text,
@@ -173,7 +173,7 @@ Adapter installation and support-level details live in [Adapter install](docs/ad
 - Start: [English documentation](docs/README.md), [Русская документация](docs/ru/README.md), [Install](docs/guides/install-and-first-run.md), [Quickstart](docs/guides/quickstart.md), [Beginner and advanced workflows](docs/guides/beginner-and-advanced-workflows.md), [Commands by task](docs/guides/commands-by-task.md), [Research workflow](docs/guides/research-workflow.md), [Lifecycle task scenarios](docs/guides/lifecycle-cookbook.md), and [Code review workflows](docs/guides/code-review-workflows.md).
 - Planning and adapters: [Issue to specification drafts](docs/guides/issue-to-spec.md), [Adapter install](docs/adapters/install.md), and [Adapter support matrix](docs/adapters/support-matrix.md).
 - Reference: [System architecture](docs/architecture/system-architecture.md), [workflow customization and execution controls](docs/reference/workflow-customization.md), [execution strategy](docs/reference/execution-strategy.md), [CLI reference](docs/reference/cli.md), [Research evidence](docs/reference/research-evidence.md), [Source of truth](docs/reference/source-of-truth.md), [Managed lifecycle runner](docs/reference/managed-lifecycle-runner.md), [Managed adapter sessions](docs/reference/managed-adapter-sessions.md), [Portable Agent Plugins](docs/reference/agent-plugins.md), [Plugin publication](docs/reference/plugin-publication.md), [Implementation audit](docs/reference/implementation-audit.md), [Plan completeness](docs/reference/plan-completeness.md), [Public contracts](docs/reference/public-contracts.md), and [Readiness diagnostics](docs/reference/readiness-diagnostics.md).
-- Quality and resources: [Reference-task evaluation](docs/reference/reference-task-evaluation.md), [model routing](docs/reference/model-routing.md), [quality-cost learning](docs/reference/quality-cost-learning.md), [lifecycle cost accounting](docs/reference/lifecycle-cost.md), [host-local token accounting](docs/reference/host-local-token-accounting.md), [process execution observability](docs/reference/process-execution-observability.md), [Usage export](docs/reference/usage-export.md), and [Evidence integrity](docs/reference/evidence-integrity.md).
+- Quality and resources: [Reference-task evaluation](docs/reference/reference-task-evaluation.md), [model routing](docs/reference/model-routing.md), [quality-cost learning](docs/reference/quality-cost-learning.md), [performance and resource budgets](docs/reference/performance-and-resource-budgets.md), [lifecycle cost accounting](docs/reference/lifecycle-cost.md), [host-local token accounting](docs/reference/host-local-token-accounting.md), [process execution observability](docs/reference/process-execution-observability.md), [Usage export](docs/reference/usage-export.md), and [Evidence integrity](docs/reference/evidence-integrity.md).
 - Profiles and operations: [Project workflow presets](docs/reference/workflow-presets.md), [Project workflow profile](docs/reference/project-workflow-profile.md), [Read-only status views](docs/reference/read-only-status-view.md), [Adapter progress bridge](docs/reference/automatic-progress-bridge.md), [Sandbox boundaries](docs/reference/sandbox-boundaries.md), [Import mappers](docs/reference/import-mappers.md), [Episode retrieval](docs/reference/episode-retrieval.md), [Runner recovery](docs/reference/runner-recovery.md), [Cross-check profile](docs/reference/cross-check-profile.md), [Review Mesh](docs/reference/review-mesh.md), [Bug Forensics profile](docs/reference/bug-forensics.md), and [Bug Forensics context budget](docs/reference/bug-forensics-context-budget.md).
 - Release assets: [Task templates](templates/tasks/README.md), [Neutrality scanning](docs/reference/neutrality.md), and [Release security](docs/security/release-security.md).
 

{agent_lifecycle_kit-1.77.0 → agent_lifecycle_kit-1.78.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agent-lifecycle-kit"
-version = "1.77.0"
+version = "1.78.0"
 description = "Provider-neutral lifecycle control layer that helps coding agents plan, execute, validate, and prove software tasks to completion."
 readme = "README.md"
 requires-python = ">=3.11,<3.15"

{agent_lifecycle_kit-1.77.0 → agent_lifecycle_kit-1.78.0}/src/agent_lifecycle/_version.py

@@ -1,3 +1,3 @@
 """Package version."""
 
-__version__ = "1.77.0"
+__version__ = "1.78.0"

{agent_lifecycle_kit-1.77.0 → agent_lifecycle_kit-1.78.0}/src/agent_lifecycle/adapter_sessions/launch_execution.py

@@ -2,9 +2,6 @@
 
 from __future__ import annotations
 
-import hashlib
-import os
-import subprocess
 from collections.abc import Callable
 from pathlib import Path
 from typing import Any
@@ -24,6 +21,7 @@ from agent_lifecycle.adapter_sessions.planning_launch import run_planning_launch
 from agent_lifecycle.adapter_sessions.qualification import (
     shipped_profile_digest,
 )
+from agent_lifecycle.adapter_sessions.worktree_identity import capture_git_worktree_identity
 from agent_lifecycle.contracts import LifecycleError, canonical_digest, read_json_object
 from agent_lifecycle.host_protocol.validation import validate_managed_launch_profile
 
@@ -305,89 +303,6 @@ def _state_task(state: dict[str, Any], task_id: str) -> dict[str, Any]:
     raise LifecycleError("local-launch-task-missing", "task is not present in workflow state", {"taskId": task_id})
 
 
-def capture_git_worktree_identity(project_root: Path) -> dict[str, Any]:
-    """Capture normalized authoritative Git content without requiring cleanliness."""
-
-    root = project_root.resolve()
-    head = _git_bytes(root, ["rev-parse", "HEAD"]).decode("ascii", errors="strict").strip()
-    staged = _git_bytes(root, ["diff", "--cached", "--binary", "--no-ext-diff"])
-    unstaged = _git_bytes(root, ["diff", "--binary", "--no-ext-diff"])
-    submodules = _git_bytes(root, ["submodule", "status", "--recursive"])
-    untracked_raw = _git_bytes(root, ["ls-files", "--others", "--exclude-standard", "-z"])
-    untracked_rows: list[dict[str, Any]] = []
-    total_bytes = 0
-    for raw_name in sorted(item for item in untracked_raw.split(b"\0") if item):
-        relative = os.fsdecode(raw_name)
-        path = root / relative
-        try:
-            before = path.lstat()
-            if path.is_symlink():
-                payload = os.fsencode(path.readlink())
-                kind = "symlink"
-            else:
-                payload = path.read_bytes()
-                kind = "file"
-            after = path.lstat()
-        except OSError as exc:
-            raise LifecycleError(
-                "planning-worktree-read-race",
-                "failed to capture an untracked worktree entry",
-                {"errorType": type(exc).__name__},
-            ) from exc
-        if (before.st_size, before.st_mtime_ns) != (after.st_size, after.st_mtime_ns):
-            raise LifecycleError(
-                "planning-worktree-read-race",
-                "untracked worktree entry changed during identity capture",
-            )
-        total_bytes += len(payload)
-        untracked_rows.append(
-            {
-                "pathBytesSha256": hashlib.sha256(raw_name).hexdigest(),
-                "kind": kind,
-                "bytes": len(payload),
-                "sha256": hashlib.sha256(payload).hexdigest(),
-            }
-        )
-    body = {
-        "schemaVersion": "agent-planning-worktree-identity.v1",
-        "head": head,
-        "stagedDiffSha256": hashlib.sha256(staged).hexdigest(),
-        "unstagedDiffSha256": hashlib.sha256(unstaged).hexdigest(),
-        "submoduleStateSha256": hashlib.sha256(submodules).hexdigest(),
-        "untrackedTreeSha256": canonical_digest({"entries": untracked_rows}),
-        "untrackedCount": len(untracked_rows),
-        "untrackedBytes": total_bytes,
-        "ignoredLocalStateExcluded": True,
-    }
-    return {**body, "identityDigest": canonical_digest(body)}
-
-
-def _git_bytes(root: Path, args: list[str]) -> bytes:
-    try:
-        result = subprocess.run(
-            ["git", *args],
-            cwd=root,
-            shell=False,
-            stdin=subprocess.DEVNULL,
-            capture_output=True,
-            timeout=10,
-            check=False,
-        )
-    except (OSError, subprocess.TimeoutExpired) as exc:
-        raise LifecycleError(
-            "planning-worktree-identity-failed",
-            "Git identity capture failed closed",
-            {"errorType": type(exc).__name__},
-        ) from exc
-    if result.returncode != 0:
-        raise LifecycleError(
-            "planning-worktree-identity-failed",
-            "Git identity command failed closed",
-            {"command": args[0], "exitCode": result.returncode},
-        )
-    return result.stdout
-
-
 def _blocked_planning_launch(
     *,
     adapter_id: str,

{agent_lifecycle_kit-1.77.0 → agent_lifecycle_kit-1.78.0}/src/agent_lifecycle/adapter_sessions/process_telemetry.py

@@ -11,6 +11,8 @@ from typing import Any
 class ProcessTelemetry:
     """Capture monotonic wall time and best-effort local process facts."""
 
+    GROUP_SAMPLE_INTERVAL_NS = 250_000_000
+
     def __init__(self, *, pid: int | None, group_id: int | None = None) -> None:
         self.pid = pid
         self.group_id = group_id
@@ -23,10 +25,19 @@ class ProcessTelemetry:
         self._memory_source = "none"
         self._process_source = "none"
         self._sample_count = 0
-        self.sample()
-
-    def sample(self) -> dict[str, Any]:
-        snapshot = capture_process_snapshot(self.pid, self.group_id)
+        self._last_group_sample_ns: int | None = None
+        self.sample(force_group=True)
+
+    def sample(self, *, force_group: bool = False) -> dict[str, Any]:
+        now_ns = time.monotonic_ns()
+        sample_group = (
+            force_group
+            or self._last_group_sample_ns is None
+            or now_ns - self._last_group_sample_ns >= self.GROUP_SAMPLE_INTERVAL_NS
+        )
+        snapshot = capture_process_snapshot(self.pid, self.group_id, sample_group=sample_group)
+        if sample_group:
+            self._last_group_sample_ns = now_ns
         self._sample_count += 1
         cpu = snapshot.get("cpuMs")
         if isinstance(cpu, (int, float)):
@@ -45,7 +56,7 @@ class ProcessTelemetry:
         return snapshot
 
     def finish(self) -> dict[str, Any]:
-        self.sample()
+        self.sample(force_group=True)
         elapsed_ms = max(0, int((time.monotonic_ns() - self.started_ns) / 1_000_000))
         cpu_ms = None
         if self._last_cpu_ms is not None and self._start_cpu_ms is not None:
@@ -53,13 +64,28 @@ class ProcessTelemetry:
         return {
             "elapsedMs": elapsed_ms,
             "cpuMs": _metric(cpu_ms, "ATTESTED" if cpu_ms is not None else "UNAVAILABLE", self._cpu_source, "ms"),
-            "peakMemoryMb": _metric(self._peak_memory_mb, "ATTESTED" if self._peak_memory_mb is not None else "UNAVAILABLE", self._memory_source, "MB"),
-            "processCount": _metric(self._peak_process_count, "ATTESTED" if self._peak_process_count is not None else "UNAVAILABLE", self._process_source, "processes"),
+            "peakMemoryMb": _metric(
+                self._peak_memory_mb,
+                "ATTESTED" if self._peak_memory_mb is not None else "UNAVAILABLE",
+                self._memory_source,
+                "MB",
+            ),
+            "processCount": _metric(
+                self._peak_process_count,
+                "ATTESTED" if self._peak_process_count is not None else "UNAVAILABLE",
+                self._process_source,
+                "processes",
+            ),
             "sampleCount": self._sample_count,
         }
 
 
-def capture_process_snapshot(pid: int | None, group_id: int | None = None) -> dict[str, Any]:
+def capture_process_snapshot(
+    pid: int | None,
+    group_id: int | None = None,
+    *,
+    sample_group: bool = True,
+) -> dict[str, Any]:
     """Read only local OS data; unavailable platforms return explicit gaps."""
 
     if pid is None:
@@ -67,7 +93,7 @@ def capture_process_snapshot(pid: int | None, group_id: int | None = None) -> di
     if os.name == "posix":
         proc = Path("/proc") / str(pid)
         if proc.exists():
-            snapshot = _linux_snapshot(proc, group_id)
+            snapshot = _linux_snapshot(proc, group_id, sample_group=sample_group)
             if snapshot:
                 return snapshot
         # resource is portable across Unix, but RUSAGE_CHILDREN is aggregate;
@@ -89,7 +115,7 @@ def capture_process_snapshot(pid: int | None, group_id: int | None = None) -> di
     return {"processCount": 1, "processSource": "direct-child"}
 
 
-def _linux_snapshot(proc: Path, group_id: int | None) -> dict[str, Any]:
+def _linux_snapshot(proc: Path, group_id: int | None, *, sample_group: bool) -> dict[str, Any]:
     try:
         stat = (proc / "stat").read_text(encoding="utf-8")
         right = stat.rsplit(")", 1)[1].split()
@@ -102,15 +128,19 @@ def _linux_snapshot(proc: Path, group_id: int | None) -> dict[str, Any]:
                 parts = line.split()
                 if len(parts) >= 2:
                     memory_mb = max(memory_mb or 0.0, int(parts[1]) / 1024.0)
-        count = _linux_group_count(group_id) if group_id is not None else 1
-        return {
+        snapshot = {
             "cpuMs": cpu_ms,
             "cpuSource": "procfs",
             "memoryMb": memory_mb,
             "memorySource": "procfs",
-            "processCount": count,
-            "processSource": "procfs-group" if group_id is not None else "procfs-direct",
         }
+        if group_id is None:
+            snapshot["processCount"] = 1
+            snapshot["processSource"] = "procfs-direct"
+        elif sample_group:
+            snapshot["processCount"] = _linux_group_count(group_id)
+            snapshot["processSource"] = "procfs-group"
+        return snapshot
     except (OSError, ValueError, IndexError, KeyError):
         return {}
 

agent_lifecycle_kit-1.78.0/src/agent_lifecycle/adapter_sessions/worktree_identity.py

@@ -0,0 +1,189 @@
+"""Bounded, stable Git worktree identity capture for planning launches."""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import subprocess
+import time
+from pathlib import Path
+from typing import Any
+
+from agent_lifecycle.contracts import LifecycleError, canonical_digest
+
+MAX_UNTRACKED_FILES = 100_000
+MAX_UNTRACKED_BYTES = 4 * 1024 * 1024 * 1024
+MAX_HASH_CHUNK_BYTES = 256 * 1024
+MAX_CAPTURE_SECONDS = 120.0
+
+
+def capture_git_worktree_identity(project_root: Path) -> dict[str, Any]:
+    """Capture authoritative Git content with bounded streaming reads.
+
+    The five Git commands remain ordered so the before/after launch snapshots
+    retain their existing consistency semantics. Ordinary untracked files are
+    hashed incrementally; symlinks hash only their link text and other special
+    files fail closed.
+    """
+
+    root = project_root.resolve()
+    deadline = time.monotonic() + MAX_CAPTURE_SECONDS
+    head = _git_bytes(root, ["rev-parse", "HEAD"], deadline).decode("ascii", errors="strict").strip()
+    staged = _git_bytes(root, ["diff", "--cached", "--binary", "--no-ext-diff"], deadline)
+    unstaged = _git_bytes(root, ["diff", "--binary", "--no-ext-diff"], deadline)
+    submodules = _git_bytes(root, ["submodule", "status", "--recursive"], deadline)
+    untracked_raw = _git_bytes(root, ["ls-files", "--others", "--exclude-standard", "-z"], deadline)
+    names = sorted(item for item in untracked_raw.split(b"\0") if item)
+    if len(names) > MAX_UNTRACKED_FILES:
+        raise LifecycleError(
+            "planning-worktree-untracked-limit",
+            "untracked file count exceeds the identity budget",
+            {"count": len(names), "maxFiles": MAX_UNTRACKED_FILES},
+        )
+    untracked_rows: list[dict[str, Any]] = []
+    total_bytes = 0
+    for raw_name in names:
+        _require_time(deadline)
+        relative = os.fsdecode(raw_name)
+        path = root / relative
+        before = _lstat_or_race(path)
+        path_digest = hashlib.sha256(raw_name).hexdigest()
+        if path.is_symlink():
+            payload = os.fsencode(path.readlink())
+            digest = hashlib.sha256(payload).hexdigest()
+            row_bytes = len(payload)
+            kind = "symlink"
+        elif _is_regular_file(before.st_mode):
+            digest, row_bytes = _hash_regular_file(path, deadline)
+            kind = "file"
+        else:
+            raise LifecycleError(
+                "planning-worktree-special-file",
+                "untracked identity capture rejects special files",
+                {"kind": "non-regular"},
+            )
+        after = _lstat_or_race(path)
+        if _stat_identity(before) != _stat_identity(after):
+            raise LifecycleError(
+                "planning-worktree-read-race",
+                "untracked worktree entry changed during identity capture",
+            )
+        total_bytes += row_bytes
+        if total_bytes > MAX_UNTRACKED_BYTES:
+            raise LifecycleError(
+                "planning-worktree-untracked-limit",
+                "untracked byte count exceeds the identity budget",
+                {"bytes": total_bytes, "maxBytes": MAX_UNTRACKED_BYTES},
+            )
+        untracked_rows.append(
+            {
+                "pathBytesSha256": path_digest,
+                "kind": kind,
+                "bytes": row_bytes,
+                "sha256": digest,
+            }
+        )
+    body = {
+        "schemaVersion": "agent-planning-worktree-identity.v1",
+        "head": head,
+        "stagedDiffSha256": hashlib.sha256(staged).hexdigest(),
+        "unstagedDiffSha256": hashlib.sha256(unstaged).hexdigest(),
+        "submoduleStateSha256": hashlib.sha256(submodules).hexdigest(),
+        "untrackedTreeSha256": canonical_digest({"entries": untracked_rows}),
+        "untrackedCount": len(untracked_rows),
+        "untrackedBytes": total_bytes,
+        "ignoredLocalStateExcluded": True,
+    }
+    return {**body, "identityDigest": canonical_digest(body)}
+
+
+def _hash_regular_file(path: Path, deadline: float) -> tuple[str, int]:
+    digest = hashlib.sha256()
+    total = 0
+    try:
+        with path.open("rb") as handle:
+            while True:
+                _require_time(deadline)
+                chunk = handle.read(MAX_HASH_CHUNK_BYTES)
+                if not chunk:
+                    break
+                total += len(chunk)
+                if total > MAX_UNTRACKED_BYTES:
+                    raise LifecycleError(
+                        "planning-worktree-untracked-limit",
+                        "untracked byte count exceeds the identity budget",
+                        {"bytes": total, "maxBytes": MAX_UNTRACKED_BYTES},
+                    )
+                digest.update(chunk)
+    except LifecycleError:
+        raise
+    except OSError as exc:
+        raise LifecycleError(
+            "planning-worktree-read-race",
+            "failed to capture an untracked worktree entry",
+            {"errorType": type(exc).__name__},
+        ) from exc
+    return digest.hexdigest(), total
+
+
+def _git_bytes(root: Path, args: list[str], deadline: float) -> bytes:
+    remaining = deadline - time.monotonic()
+    if remaining <= 0:
+        raise LifecycleError("planning-worktree-identity-timeout", "Git identity capture exceeded its deadline")
+    try:
+        result = subprocess.run(
+            ["git", *args],
+            cwd=root,
+            shell=False,
+            stdin=subprocess.DEVNULL,
+            capture_output=True,
+            timeout=remaining,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        raise LifecycleError(
+            "planning-worktree-identity-failed",
+            "Git identity capture failed closed",
+            {"errorType": type(exc).__name__},
+        ) from exc
+    if result.returncode != 0:
+        raise LifecycleError(
+            "planning-worktree-identity-failed",
+            "Git identity command failed closed",
+            {"command": args[0], "exitCode": result.returncode},
+        )
+    return result.stdout
+
+
+def _lstat_or_race(path: Path) -> os.stat_result:
+    try:
+        return path.lstat()
+    except OSError as exc:
+        raise LifecycleError(
+            "planning-worktree-read-race",
+            "failed to inspect an untracked worktree entry",
+            {"errorType": type(exc).__name__},
+        ) from exc
+
+
+def _is_regular_file(mode: int) -> bool:
+    return (mode & 0o170000) == 0o100000
+
+
+def _stat_identity(stat_result: os.stat_result) -> tuple[int, int, int, int, int, int]:
+    return (
+        stat_result.st_dev,
+        stat_result.st_ino,
+        stat_result.st_mode,
+        stat_result.st_size,
+        stat_result.st_mtime_ns,
+        stat_result.st_ctime_ns,
+    )
+
+
+def _require_time(deadline: float) -> None:
+    if time.monotonic() >= deadline:
+        raise LifecycleError("planning-worktree-identity-timeout", "Git identity capture exceeded its deadline")
+
+
+__all__ = ["capture_git_worktree_identity"]

agent_lifecycle_kit-1.78.0/src/agent_lifecycle/cli/command_registry.py

@@ -0,0 +1,41 @@
+"""Provider-neutral lazy CLI dispatch registry."""
+
+from __future__ import annotations
+
+COMMAND_DISPATCH = {
+    "start": ("agent_lifecycle.cli.start", "dispatch_start", True),
+    "host-launch": ("agent_lifecycle.cli.host_launch", "dispatch_host_launch", False),
+    "strategy": ("agent_lifecycle.cli.strategy", "dispatch_strategy", False),
+    "project": ("agent_lifecycle.cli.project", "dispatch_project", False),
+    "diagnose": ("agent_lifecycle.cli.dispatch_adapters", "dispatch_adapters", False),
+    "diagnostics": ("agent_lifecycle.cli.dispatch_adapters", "dispatch_adapters", False),
+    "adapter": ("agent_lifecycle.cli.dispatch_adapters", "dispatch_adapters", False),
+    "research": ("agent_lifecycle.cli.dispatch_research", "dispatch_research", False),
+    "version": ("agent_lifecycle.cli.dispatch_contracts", "dispatch_contracts", False),
+    "schema": ("agent_lifecycle.cli.dispatch_contracts", "dispatch_contracts", False),
+    "contract": ("agent_lifecycle.cli.dispatch_contracts", "dispatch_contracts", False),
+    "evidence": ("agent_lifecycle.cli.dispatch_contracts", "dispatch_contracts", False),
+    "import": ("agent_lifecycle.cli.dispatch_contracts", "dispatch_contracts", False),
+    "quality": ("agent_lifecycle.cli.dispatch_contracts", "dispatch_contracts", False),
+    "review-mesh": ("agent_lifecycle.cli.dispatch_contracts", "dispatch_contracts", False),
+    "workflow": ("agent_lifecycle.cli.dispatch_lifecycle", "dispatch_lifecycle", False),
+    "audit": ("agent_lifecycle.cli.dispatch_lifecycle", "dispatch_lifecycle", False),
+    "runner": ("agent_lifecycle.cli.dispatch_lifecycle", "dispatch_lifecycle", False),
+    "report": ("agent_lifecycle.cli.dispatch_observability", "dispatch_observability", False),
+    "context": ("agent_lifecycle.cli.dispatch_observability", "dispatch_observability", False),
+    "goal": ("agent_lifecycle.cli.dispatch_observability", "dispatch_observability", False),
+    "model": ("agent_lifecycle.cli.dispatch_observability", "dispatch_observability", False),
+    "metrics": ("agent_lifecycle.cli.dispatch_observability", "dispatch_observability", False),
+    "thread": ("agent_lifecycle.cli.dispatch_observability", "dispatch_observability", False),
+    "tier": ("agent_lifecycle.cli.dispatch_planning", "dispatch_planning", False),
+    "specification": ("agent_lifecycle.cli.dispatch_planning", "dispatch_planning", False),
+    "plan": ("agent_lifecycle.cli.dispatch_planning", "dispatch_planning", False),
+    "task": ("agent_lifecycle.cli.dispatch_planning", "dispatch_planning", False),
+    "policy": ("agent_lifecycle.cli.policy", "dispatch_policy", False),
+    "followup": ("agent_lifecycle.cli.followup", "dispatch_followup", False),
+    "worktree": ("agent_lifecycle.cli.worktree", "dispatch_worktree", False),
+    "benchmark": ("agent_lifecycle.cli.benchmarks", "dispatch_benchmark", False),
+}
+
+
+__all__ = ["COMMAND_DISPATCH"]

agent_lifecycle_kit-1.78.0/src/agent_lifecycle/cli/dispatch.py

@@ -0,0 +1,88 @@
+"""Thin root CLI dispatcher for Agent Lifecycle Kit."""
+
+from __future__ import annotations
+
+import argparse
+import importlib
+from typing import Any
+
+from agent_lifecycle.cli.command_registry import COMMAND_DISPATCH
+from agent_lifecycle.contracts import LifecycleError
+
+
+def _lazy_call(
+    module_name: str, function_name: str, args: argparse.Namespace, remainder: list[str] | None = None
+) -> dict[str, Any] | str | None:
+    function = getattr(importlib.import_module(module_name), function_name)
+    return function(args, remainder) if remainder is not None else function(args)
+
+
+def dispatch_start(args: argparse.Namespace, remainder: list[str]) -> dict[str, Any] | str | None:
+    return _lazy_call("agent_lifecycle.cli.start", "dispatch_start", args, remainder)
+
+
+def dispatch_host_launch(args: argparse.Namespace) -> dict[str, Any] | str | None:
+    return _lazy_call("agent_lifecycle.cli.host_launch", "dispatch_host_launch", args)
+
+
+def dispatch_strategy(args: argparse.Namespace) -> dict[str, Any] | str | None:
+    return _lazy_call("agent_lifecycle.cli.strategy", "dispatch_strategy", args)
+
+
+def dispatch_project(args: argparse.Namespace) -> dict[str, Any] | str | None:
+    return _lazy_call("agent_lifecycle.cli.project", "dispatch_project", args)
+
+
+def dispatch_adapters(args: argparse.Namespace) -> dict[str, Any] | str | None:
+    return _lazy_call("agent_lifecycle.cli.dispatch_adapters", "dispatch_adapters", args)
+
+
+def dispatch_research(args: argparse.Namespace) -> dict[str, Any] | str | None:
+    return _lazy_call("agent_lifecycle.cli.dispatch_research", "dispatch_research", args)
+
+
+def dispatch_contracts(args: argparse.Namespace) -> dict[str, Any] | str | None:
+    return _lazy_call("agent_lifecycle.cli.dispatch_contracts", "dispatch_contracts", args)
+
+
+def dispatch_lifecycle(args: argparse.Namespace) -> dict[str, Any] | str | None:
+    return _lazy_call("agent_lifecycle.cli.dispatch_lifecycle", "dispatch_lifecycle", args)
+
+
+def dispatch_observability(args: argparse.Namespace) -> dict[str, Any] | str | None:
+    return _lazy_call("agent_lifecycle.cli.dispatch_observability", "dispatch_observability", args)
+
+
+def dispatch_planning(args: argparse.Namespace) -> dict[str, Any] | str | None:
+    return _lazy_call("agent_lifecycle.cli.dispatch_planning", "dispatch_planning", args)
+
+
+def dispatch_policy(args: argparse.Namespace) -> dict[str, Any] | str | None:
+    return _lazy_call("agent_lifecycle.cli.policy", "dispatch_policy", args)
+
+
+def dispatch_followup(args: argparse.Namespace) -> dict[str, Any] | str | None:
+    return _lazy_call("agent_lifecycle.cli.followup", "dispatch_followup", args)
+
+
+def dispatch_worktree(args: argparse.Namespace) -> dict[str, Any] | str | None:
+    return _lazy_call("agent_lifecycle.cli.worktree", "dispatch_worktree", args)
+
+
+def dispatch_benchmark(args: argparse.Namespace) -> dict[str, Any] | str | None:
+    return _lazy_call("agent_lifecycle.cli.benchmarks", "dispatch_benchmark", args)
+
+
+def dispatch(args: argparse.Namespace, remainder: list[str]) -> dict[str, Any] | str | None:
+    """Route a parsed command without owning domain behavior or CLI output."""
+    target = COMMAND_DISPATCH.get(args.command)
+    if target is None:
+        raise LifecycleError(
+            "command-not-implemented", f"{args.command} command group is reserved but not implemented in this build"
+        )
+    _, function_name, accepts_remainder = target
+    function = globals()[function_name]
+    if accepts_remainder:
+        return function(args, remainder)
+    del remainder
+    return function(args)

{agent_lifecycle_kit-1.77.0 → agent_lifecycle_kit-1.78.0}/src/agent_lifecycle/cli/main.py

@@ -11,8 +11,9 @@ from agent_lifecycle.contracts import LifecycleError, canonical_bytes
 
 
 def main(argv: list[str] | None = None) -> int:
-    parser = build_parser()
-    args, remainder = parser.parse_known_args(argv)
+    raw_argv = list(sys.argv[1:] if argv is None else argv)
+    parser = build_parser(raw_argv)
+    args, remainder = parser.parse_known_args(raw_argv)
     try:
         if args.command == "neutrality":
             from agent_lifecycle.neutrality.cli import main as neutrality_main