@hunter-harness/workflow-harness 0.2.5 → 0.2.7

package/harness/bundles/general/codex/scripts/harness_preflight.py

@@ -313,7 +313,23 @@ def _parse_scalar(val: str) -> Any:
     return val
 
 
-def cmd_check_agents(skills_root: Path, agent: str) -> dict[str, Any]:
+def _resolve_agents_root(skills_root: Path, agents_root: Path | None) -> tuple[Path | None, str | None]:
+    """Resolve agent definitions without confusing a skills root with its sibling."""
+    if agents_root is not None:
+        return agents_root.resolve(), None
+    if skills_root.name == "skills" and skills_root.parent.name in (".claude", ".codebuddy"):
+        return (skills_root.parent / "agents").resolve(), None
+    if skills_root.name == "skills" and skills_root.parent.name in (".agents", ".cursor"):
+        return None, "CUSTOM_AGENTS_UNSUPPORTED"
+    return (skills_root / "agents").resolve(), None
+
+
+def cmd_check_agents(
+    skills_root: Path,
+    agent: str,
+    *,
+    agents_root: Path | None = None,
+) -> dict[str, Any]:
     skills_root = skills_root.resolve()
     agent_name = agent.strip()
     if not agent_name:
@@ -325,9 +341,23 @@ def cmd_check_agents(skills_root: Path, agent: str) -> dict[str, Any]:
             "reason": "agent name is empty",
         }
 
+    resolved_agents_root, capability_error = _resolve_agents_root(skills_root, agents_root)
+    if capability_error is not None:
+        return {
+            "ok": True,
+            "action": "check-agents",
+            "agent": agent_name,
+            "usable": False,
+            "definitionValid": False,
+            "runtimeSupported": False,
+            "reasonCode": capability_error,
+            "reason": "current adapter runtime does not support custom agent definitions; use main-session fallback",
+        }
+
+    assert resolved_agents_root is not None
     # Accept bare name or with .md
     filename = agent_name if agent_name.endswith(".md") else f"{agent_name}.md"
-    agent_path = skills_root / "agents" / filename
+    agent_path = resolved_agents_root / filename
 
     if not agent_path.is_file():
         return {
@@ -335,7 +365,11 @@ def cmd_check_agents(skills_root: Path, agent: str) -> dict[str, Any]:
             "action": "check-agents",
             "agent": agent_name,
             "path": str(agent_path),
+            "agentsRoot": str(resolved_agents_root),
             "usable": False,
+            "definitionValid": False,
+            "runtimeSupported": True,
+            "reasonCode": "AGENT_DEFINITION_NOT_FOUND",
             "reason": f"agent file not found: {agent_path}",
         }
 
@@ -390,7 +424,11 @@ def cmd_check_agents(skills_root: Path, agent: str) -> dict[str, Any]:
         "action": "check-agents",
         "agent": agent_name,
         "path": str(agent_path),
+        "agentsRoot": str(resolved_agents_root),
         "usable": True,
+        "definitionValid": True,
+        "runtimeSupported": True,
+        "reasonCode": "READY",
         "reason": "agent file exists; frontmatter parsed; tools declared",
         "name": name_field,
         "tools": tools,
@@ -431,6 +469,7 @@ def build_parser() -> argparse.ArgumentParser:
 
     p_agents = sub.add_parser("check-agents", help="Validate agent definition usability")
     p_agents.add_argument("--skills-root", required=True, type=Path)
+    p_agents.add_argument("--agents-root", type=Path)
     p_agents.add_argument("--agent", required=True)
     p_agents.add_argument("--json", action="store_true")
 
@@ -459,7 +498,11 @@ def main(argv: list[str] | None = None) -> int:
         )
         return emit_json(result, ok=bool(result.get("ok", False)))
     if args.command == "check-agents":
-        result = cmd_check_agents(args.skills_root, args.agent)
+        result = cmd_check_agents(
+            args.skills_root,
+            args.agent,
+            agents_root=args.agents_root,
+        )
         return emit_json(result, ok=True)
 
     parser.error(f"unknown command: {args.command}")

package/harness/bundles/general/codex/scripts/harness_profile.py

@@ -223,8 +223,8 @@ def _java_commands(reactor_modules: list[str], pom_hash: str) -> dict[str, Any]:
             "basis": dict(basis),
         },
         "package": {
-            "command": "mvn -f pom.xml package '-Dmaven.test.skip=true'",
-            "argvTemplate": ["mvn", "-f", "pom.xml", "package", "-Dmaven.test.skip=true"],
+            "command": "mvn -f pom.xml clean package '-Dmaven.test.skip=true'",
+            "argvTemplate": ["mvn", "-f", "pom.xml", "clean", "package", "-Dmaven.test.skip=true"],
             "scope": "module",
             "inputs": _cmd_inputs(reactor_modules, pom=True, main=True, test=True),
             "coverage": "package",

package/harness/bundles/general/codex/scripts/harness_service.py

@@ -194,6 +194,8 @@ def resolve_service_start(
     change_name: str | None = None,
     worktree_root: Path | None = None,
     overlay_path: str | None = None,
+    leased_port: int | None = None,
+    lease_owner: str | None = None,
 ) -> dict[str, Any]:
     """从模板 serviceStart + runtime context 生成 resolved serviceStart。
 
@@ -220,6 +222,16 @@ def resolve_service_start(
     # runtime profile 注入：持久 profile 留空时用 change_name；非空则保留
     if not str(resolved.get("profile") or "").strip():
         resolved["profile"] = change_name or "local-dev"
+    if leased_port is not None:
+        if not lease_owner:
+            raise ValueError("lease owner is required when leased port is provided")
+        resolved["leasedPort"] = leased_port
+        resolved["leaseOwner"] = lease_owner
+        resolved["port"] = leased_port
+        for field in ("command", "healthUrl", "healthFile", "overlayPath"):
+            value = resolved.get(field)
+            if isinstance(value, str):
+                resolved[field] = value.replace("{leasedPort}", str(leased_port))
     # worktree_root 预留给未来相对 overlay 路径解析（spec §3.6 state snapshot）；
     # 不写入返回值，避免污染 session。
     _ = worktree_root
@@ -914,7 +926,7 @@ def build_session(
 ) -> dict[str, Any]:
     profile_name = service_start.get("profile") or "local-dev"
     overlay = service_start.get("overlayPath") or ""
-    return {
+    session = {
         "pid": pid,
         "startedBy": "AI",
         "moduleInputsHash": module_inputs_hash,
@@ -925,6 +937,10 @@ def build_session(
         "startedAt": started_at or now_iso(),
         "command": command,
     }
+    if isinstance(service_start.get("leasedPort"), int):
+        session["leasedPort"] = service_start["leasedPort"]
+        session["leaseOwner"] = service_start.get("leaseOwner")
+    return session
 
 
 def compute_module_hash(
@@ -1015,12 +1031,16 @@ def cmd_ensure(args: argparse.Namespace) -> int:
     # 含 worktree/change 陈旧持久值时拒绝（修复输入端陈旧 profile）。
     change_name = getattr(args, "change_name", None) or change_dir.name
     overlay = getattr(args, "overlay", None)
+    leased_port = getattr(args, "leased_port", None)
+    lease_owner = str(getattr(args, "lease_owner", None) or "").strip() or None
     try:
         service_start = resolve_service_start(
             profile,
             change_name=change_name,
             worktree_root=project,
             overlay_path=overlay,
+            leased_port=leased_port,
+            lease_owner=lease_owner,
         )
     except ValueError as exc:
         return emit_error(str(exc), as_json=as_json)
@@ -1084,6 +1104,8 @@ def cmd_ensure(args: argparse.Namespace) -> int:
                 and session.get("startCommandHash") == current_cmd_hash
                 and session.get("profile") == current_profile
                 and session.get("overlayPath") == current_overlay
+                and session.get("leasedPort") == service_start.get("leasedPort")
+                and session.get("leaseOwner") == service_start.get("leaseOwner")
             )
             if fingerprint_match:
                 payload = {
@@ -1389,6 +1411,17 @@ def build_parser() -> argparse.ArgumentParser:
         default=None,
         help="runtime overlay path injected into resolved serviceStart",
     )
+    p_ensure.add_argument(
+        "--leased-port",
+        type=int,
+        default=None,
+        help="port allocated by harness_change.py lease-port",
+    )
+    p_ensure.add_argument(
+        "--lease-owner",
+        default=None,
+        help="run id that owns --leased-port",
+    )
     p_ensure.add_argument("--json", action="store_true")
     p_ensure.set_defaults(func=cmd_ensure)
 

package/harness/bundles/general/codex/scripts/harness_state.py

@@ -12,9 +12,11 @@ Python 3.10+ stdlib only. UTF-8 without BOM. Windows path friendly.
 from __future__ import annotations
 
 import datetime as dt
+import argparse
 import hashlib
 import json
 import os
+import subprocess
 import sys
 from pathlib import Path
 from typing import Any
@@ -177,3 +179,149 @@ def refresh_segments(
     refreshed["segments"] = refreshed_segments
     refreshed["generatedAt"] = now_iso()
     return refreshed
+
+
+def _git(project: Path, *args: str) -> str:
+    proc = subprocess.run(
+        ["git", "-C", str(project), *args],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        check=False,
+    )
+    return proc.stdout.strip() if proc.returncode == 0 else ""
+
+
+def _existing_files(paths: list[Path]) -> list[str]:
+    return sorted({str(path.resolve()) for path in paths if path.is_file()})
+
+
+def discover_segment_files(
+    project: Path, change_dir: Path, *, base: str = "", head: str = "HEAD"
+) -> dict[str, list[str]]:
+    """Discover the compact inputs shared by plan/run/test/review/submit."""
+    project = project.resolve()
+    rules = [project / "AGENTS.md", project / "CLAUDE.md"]
+    for pattern in (
+        ".claude/rules/**/*",
+        ".cursor/rules/**/*",
+        ".codebuddy/rules/**/*",
+        ".codebuddy/.rules/**/*",
+    ):
+        rules.extend(project.glob(pattern))
+
+    profile = [
+        project / ".harness/config/build-profile.json",
+        project / ".harness/context-index.json",
+        project / "project.yaml",
+        project / "harness.json",
+    ]
+    codebase_map = list((project / ".harness/codebase/map").glob("**/*"))
+    knowledge = [
+        project / ".harness/knowledge/index.json",
+        project / ".harness/knowledge/status.json",
+        project / ".harness/knowledge/config.json",
+    ]
+    change_inputs: list[Path] = []
+    for folder in ("spec", "plans", "meta"):
+        change_inputs.extend((change_dir / folder).glob("**/*"))
+    change_inputs = [path for path in change_inputs if path != snapshot_path(change_dir)]
+
+    changed_names: list[str] = []
+    if base:
+        raw = _git(project, "diff", "--name-only", "--diff-filter=ACMRT", f"{base}..{head}")
+        changed_names = [line for line in raw.splitlines() if line.strip()]
+    code = [project / name for name in changed_names]
+    return {
+        "profile": _existing_files(profile),
+        "rules": _existing_files(rules),
+        "map": _existing_files(codebase_map),
+        "knowledge": _existing_files(knowledge),
+        "change": _existing_files(change_inputs),
+        "code": _existing_files(code),
+    }
+
+
+def capture_current_state(
+    *,
+    project: Path,
+    change_dir: Path,
+    change_name: str,
+    worktree_root: Path,
+    base: str = "",
+    head: str = "HEAD",
+) -> tuple[dict[str, Any], list[str]]:
+    resolved_head = _git(project, "rev-parse", head) or head
+    resolved_base = _git(project, "rev-parse", base) if base else ""
+    files = discover_segment_files(project, change_dir, base=resolved_base, head=resolved_head)
+    previous = load_snapshot(change_dir)
+    fresh = capture_snapshot(
+        change_dir,
+        change_name=change_name,
+        project=project,
+        worktree_root=worktree_root,
+        base=resolved_base,
+        head=resolved_head,
+        segment_files=files,
+    )
+    changed: list[str] = []
+    if previous:
+        old_segments = previous.get("segments") or {}
+        for name, segment in fresh["segments"].items():
+            old = old_segments.get(name)
+            if isinstance(old, dict) and old.get("fingerprint") == segment.get("fingerprint"):
+                segment["capturedAt"] = old.get("capturedAt", segment["capturedAt"])
+            else:
+                changed.append(name)
+    else:
+        changed = list(fresh["segments"])
+    write_snapshot(change_dir, fresh)
+    return fresh, changed
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Capture reusable Harness state")
+    sub = parser.add_subparsers(dest="command", required=True)
+    capture = sub.add_parser("capture", help="capture or refresh changed segments")
+    capture.add_argument("--project", default=".")
+    capture.add_argument("--change-dir", required=True)
+    capture.add_argument("--change-name")
+    capture.add_argument("--worktree-root")
+    capture.add_argument("--base", default="")
+    capture.add_argument("--head", default="HEAD")
+    capture.add_argument("--json", action="store_true")
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    project = Path(args.project).resolve()
+    change_dir = Path(args.change_dir).resolve()
+    name = args.change_name or change_dir.name
+    worktree = Path(args.worktree_root).resolve() if args.worktree_root else project
+    snapshot, changed = capture_current_state(
+        project=project,
+        change_dir=change_dir,
+        change_name=name,
+        worktree_root=worktree,
+        base=args.base,
+        head=args.head,
+    )
+    result = {
+        "ok": True,
+        "path": str(snapshot_path(change_dir)),
+        "changedSegments": changed,
+        "reusedSegments": sorted(set(snapshot["segments"]) - set(changed)),
+        "git": snapshot["git"],
+    }
+    if args.json:
+        print(json.dumps(result, ensure_ascii=False))
+    else:
+        print(f"state snapshot: {result['path']}")
+        print(f"changed: {', '.join(changed) if changed else 'none'}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/harness/bundles/general/codex/scripts/harness_test_guard.py

@@ -24,6 +24,7 @@ from typing import Any
 SCHEMA_VERSION = 1
 MODE = "force-track-touched"
 MANIFEST_REL = Path("evidence") / "test-tracking.json"
+SNAPSHOT_REL = Path("evidence") / "test-guard-snapshot.json"
 PROFILE_REL = Path(".harness") / "config" / "build-profile.json"
 REASONS = ("tdd-created", "stale-test-repair", "test-updated")
 
@@ -125,7 +126,7 @@ def _exclusive_lock(path: Path, *, wait_seconds: float) -> Any:
     while descriptor is None:
         try:
             descriptor = os.open(path, os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0o600)
-        except FileExistsError as exc:
+        except (FileExistsError, PermissionError) as exc:
             if time.monotonic() >= deadline:
                 raise LockUnavailable(str(path)) from exc
             time.sleep(0.01)
@@ -137,22 +138,41 @@ def _exclusive_lock(path: Path, *, wait_seconds: float) -> Any:
         path.unlink(missing_ok=True)
 
 
+def _state_project_root(project: Path) -> Path:
+    result = _git(project, "rev-parse", "--git-common-dir")
+    if result.returncode != 0 or not result.stdout.strip():
+        return project
+    common = Path(result.stdout.strip())
+    if not common.is_absolute():
+        common = project / common
+    resolved = common.resolve()
+    return resolved.parent if resolved.name == ".git" else project
+
+
 def _change_dir(project: Path, change_dir: Path | str) -> Path | None:
+    state_project = _state_project_root(project)
     candidate = Path(change_dir)
     if not candidate.is_absolute():
-        candidate = project / candidate
+        candidate = (
+            state_project / candidate
+            if candidate.parts[:2] == (".harness", "changes")
+            else project / candidate
+        )
     resolved = candidate.resolve()
-    return resolved if _inside(resolved, project) else None
+    allowed_roots = {
+        (project / ".harness" / "changes").resolve(),
+        (state_project / ".harness" / "changes").resolve(),
+    }
+    return resolved if any(_inside(resolved, root) for root in allowed_roots) else None
 
 
-def _manifest_path(project: Path, change_root: Path) -> Path | None:
+def _manifest_path(change_root: Path) -> Path | None:
     evidence = change_root / MANIFEST_REL.parent
     manifest = change_root / MANIFEST_REL
     expected_evidence = evidence.absolute()
     resolved_evidence = evidence.resolve()
     if (
-        not _inside(change_root.resolve(), project)
-        or not _inside(resolved_evidence, project)
+        not _inside(resolved_evidence, change_root.resolve())
         or os.path.normcase(str(resolved_evidence))
         != os.path.normcase(str(expected_evidence))
     ):
@@ -160,9 +180,12 @@ def _manifest_path(project: Path, change_root: Path) -> Path | None:
     return manifest
 
 
-def _manifest_target_inside(project: Path, manifest: Path) -> bool:
+def _manifest_target_inside(change_root: Path, manifest: Path) -> bool:
     resolved = manifest.resolve()
-    return _inside(resolved, project) and _inside(resolved, manifest.parent.absolute())
+    return (
+        _inside(resolved, change_root.resolve())
+        and _inside(resolved, manifest.parent.absolute())
+    )
 
 
 def _profile_config(project: Path) -> tuple[list[str], list[str]] | None:
@@ -325,13 +348,13 @@ def record(
         assert path is not None and rel is not None
         validated.append((path, rel))
 
-    manifest_path = _manifest_path(project_root, change_root)
+    manifest_path = _manifest_path(change_root)
     if manifest_path is None:
         return _result(False, action, "MANIFEST_PATH_OUTSIDE_PROJECT", [])
     lock_path = manifest_path.with_name(manifest_path.name + ".lock")
     try:
         with _exclusive_lock(lock_path, wait_seconds=5.0):
-            if not _manifest_target_inside(project_root, manifest_path):
+            if not _manifest_target_inside(change_root, manifest_path):
                 return _result(
                     False, action, "MANIFEST_PATH_OUTSIDE_PROJECT", []
                 )
@@ -378,10 +401,10 @@ def record(
 
 
 def _stage_locked(
-    project_root: Path, manifest_path: Path, index_path: Path
+    project_root: Path, change_root: Path, manifest_path: Path, index_path: Path
 ) -> dict[str, Any]:
     action = "stage"
-    if not _manifest_target_inside(project_root, manifest_path):
+    if not _manifest_target_inside(change_root, manifest_path):
         return _result(False, action, "MANIFEST_PATH_OUTSIDE_PROJECT", [])
     try:
         manifest = _read_json(manifest_path)
@@ -444,13 +467,164 @@ def _stage_locked(
         temp_index.unlink(missing_ok=True)
 
 
+def _glob_files_for_pattern(base: Path, pattern: str) -> list[Path]:
+    normalized = pattern.replace("\\", "/")
+    if normalized.endswith("/**"):
+        prefix = normalized[:-3].rstrip("/")
+        root = base / prefix
+        if not root.is_dir():
+            return []
+        return [path for path in root.rglob("*") if path.is_file()]
+    return [path for path in base.glob(normalized) if path.is_file()]
+
+
+def _enumerate_allowed_test_files(project_root: Path) -> dict[str, str]:
+    """Map repo-relative test path -> sha256 for all allowed existing files."""
+    found: dict[str, str] = {}
+    config = _profile_config(project_root)
+    if config is None:
+        patterns = ["test/**", "tests/**", "src/test/**"]
+    else:
+        patterns, _excluded = config
+    base = project_root.resolve()
+    seen: set[str] = set()
+    for pattern in patterns:
+        for match in _glob_files_for_pattern(base, pattern):
+            resolved = match.resolve()
+            if not _inside(resolved, base):
+                continue
+            rel = resolved.relative_to(base).as_posix()
+            if rel in seen or not _allowed_test_path(project_root, rel):
+                continue
+            seen.add(rel)
+            found[rel] = _sha256(resolved)
+    return found
+
+
+def begin(project: Path | str, change_dir: Path | str) -> dict[str, Any]:
+    action = "begin"
+    project_root = Path(project).resolve()
+    change_root = _change_dir(project_root, change_dir)
+    if change_root is None:
+        return _result(False, action, "CHANGE_DIR_OUTSIDE_PROJECT", [])
+    manifest_path = _manifest_path(change_root)
+    if manifest_path is None:
+        return _result(False, action, "MANIFEST_PATH_OUTSIDE_PROJECT", [])
+    snapshot_path = change_root / SNAPSHOT_REL
+    if not _manifest_target_inside(change_root, snapshot_path):
+        return _result(False, action, "SNAPSHOT_PATH_OUTSIDE_PROJECT", [])
+
+    files = _enumerate_allowed_test_files(project_root)
+    snapshot = {
+        "schemaVersion": SCHEMA_VERSION,
+        "mode": MODE,
+        "projectRoot": str(project_root),
+        "capturedAt": time.strftime("%Y-%m-%dT%H:%M:%S"),
+        "files": [
+            {"path": rel, "sha256": digest, "ignored": _is_ignored(project_root, rel)}
+            for rel, digest in sorted(files.items())
+        ],
+    }
+    _write_json(snapshot_path, snapshot)
+    return _result(
+        True,
+        action,
+        "SNAPSHOT_CAPTURED",
+        list(files),
+        snapshotPath=str(snapshot_path),
+        fileCount=len(files),
+    )
+
+
+def close(project: Path | str, change_dir: Path | str) -> dict[str, Any]:
+    action = "close"
+    project_root = Path(project).resolve()
+    change_root = _change_dir(project_root, change_dir)
+    if change_root is None:
+        return _result(False, action, "CHANGE_DIR_OUTSIDE_PROJECT", [])
+    snapshot_path = change_root / SNAPSHOT_REL
+    if not snapshot_path.is_file():
+        return _result(False, action, "SNAPSHOT_MISSING", [])
+    try:
+        snapshot = _read_json(snapshot_path)
+    except (OSError, json.JSONDecodeError) as exc:
+        return _result(False, action, "SNAPSHOT_INVALID", [], error=str(exc))
+    if (
+        not isinstance(snapshot, dict)
+        or snapshot.get("schemaVersion") != SCHEMA_VERSION
+        or snapshot.get("projectRoot") != str(project_root)
+    ):
+        return _result(False, action, "SNAPSHOT_INVALID", [])
+
+    before_entries = snapshot.get("files")
+    if not isinstance(before_entries, list):
+        return _result(False, action, "SNAPSHOT_INVALID", [])
+    before: dict[str, dict[str, Any]] = {}
+    for item in before_entries:
+        if not isinstance(item, dict):
+            return _result(False, action, "SNAPSHOT_INVALID", [])
+        rel = item.get("path")
+        digest = item.get("sha256")
+        if not isinstance(rel, str) or not rel or not isinstance(digest, str):
+            return _result(False, action, "SNAPSHOT_INVALID", [])
+        path, normalized, error = _validate_file(project_root, rel)
+        if error:
+            return _result(False, action, error, [rel])
+        if normalized != rel or path is None:
+            return _result(False, action, "PATH_ESCAPE", [rel])
+        before[rel] = item
+
+    current = _enumerate_allowed_test_files(project_root)
+    for rel in current:
+        path, normalized, error = _validate_file(project_root, rel)
+        if error:
+            return _result(False, action, error, [rel])
+        if normalized != rel or path is None:
+            return _result(False, action, "PATH_ESCAPE", [rel])
+
+    touched: list[tuple[str, str]] = []
+    for rel, digest in current.items():
+        if rel not in before:
+            touched.append((rel, "tdd-created"))
+            continue
+        if before[rel]["sha256"] != digest:
+            touched.append((rel, "test-updated"))
+
+    recorded: list[str] = []
+    for rel, reason in touched:
+        result = record(project_root, change_root, [str(project_root / rel)], reason)
+        if not result.get("ok"):
+            code = result.get("code", "RECORD_FAILED")
+            if code == "TEST_PATH_NOT_ALLOWED":
+                return _result(False, action, "UNCLASSIFIABLE_TEST", [rel])
+            return result
+        recorded.append(rel)
+
+    return _result(
+        True,
+        action,
+        "CLOSED",
+        recorded,
+        recordedCount=len(recorded),
+        unchangedPreexisting=len(before) - sum(1 for rel, _ in touched if rel in before),
+    )
+
+
+def mark(
+    project: Path | str,
+    change_dir: Path | str,
+    files: list[str],
+) -> dict[str, Any]:
+    return record(project, change_dir, files, "stale-test-repair")
+
+
 def stage(project: Path | str, change_dir: Path | str) -> dict[str, Any]:
     action = "stage"
     project_root = Path(project).resolve()
     change_root = _change_dir(project_root, change_dir)
     if change_root is None:
         return _result(False, action, "CHANGE_DIR_OUTSIDE_PROJECT", [])
-    manifest_path = _manifest_path(project_root, change_root)
+    manifest_path = _manifest_path(change_root)
     if manifest_path is None:
         return _result(False, action, "MANIFEST_PATH_OUTSIDE_PROJECT", [])
 
@@ -468,7 +642,9 @@ def stage(project: Path | str, change_dir: Path | str) -> dict[str, Any]:
             manifest_lock = manifest_path.with_name(manifest_path.name + ".lock")
             try:
                 with _exclusive_lock(manifest_lock, wait_seconds=0.0):
-                    return _stage_locked(project_root, manifest_path, index_path)
+                    return _stage_locked(
+                        project_root, change_root, manifest_path, index_path
+                    )
             except LockUnavailable:
                 return _result(False, action, "MANIFEST_LOCKED", [])
     except LockUnavailable:
@@ -488,10 +664,30 @@ def main(argv: list[str] | None = None) -> int:
     stage_parser.add_argument("--project", required=True)
     stage_parser.add_argument("--change-dir", required=True)
     stage_parser.add_argument("--json", action="store_true")
+    begin_parser = sub.add_parser("begin")
+    begin_parser.add_argument("--project", required=True)
+    begin_parser.add_argument("--change-dir", required=True)
+    begin_parser.add_argument("--json", action="store_true")
+    close_parser = sub.add_parser("close")
+    close_parser.add_argument("--project", required=True)
+    close_parser.add_argument("--change-dir", required=True)
+    close_parser.add_argument("--json", action="store_true")
+    mark_parser = sub.add_parser("mark")
+    mark_parser.add_argument("--project", required=True)
+    mark_parser.add_argument("--change-dir", required=True)
+    mark_parser.add_argument("--files", required=True)
+    mark_parser.add_argument("--json", action="store_true")
     args = parser.parse_args(argv)
     if args.action == "record":
         files = [item.strip() for item in args.files.split(",") if item.strip()]
         result = record(args.project, args.change_dir, files, args.reason)
+    elif args.action == "begin":
+        result = begin(args.project, args.change_dir)
+    elif args.action == "close":
+        result = close(args.project, args.change_dir)
+    elif args.action == "mark":
+        files = [item.strip() for item in args.files.split(",") if item.strip()]
+        result = mark(args.project, args.change_dir, files)
     else:
         result = stage(args.project, args.change_dir)
     print(json.dumps(result, ensure_ascii=False, indent=2 if args.json else None))