@ikon85/agent-workflow-kit 0.42.1 → 0.44.0

package/scripts/worktree-lifecycle/ignore_seed.py

@@ -5,7 +5,7 @@ The shipped skills write `PLAN.md`, `PLAN-REVIEW-LOG.md`, and `ANNAHMEN.md`
 into a session worktree, but `.gitignore` is a consumer file the kit does not
 own: `init` and `update` never touch it. This helper is the one place that
 closes that gap, and it closes it only when a user explicitly approves the
-offer inside `/setup-workflow` (ADR 0008).
+offer inside `/setup-workflow`.
 
 Contract:
 

package/scripts/worktree-lifecycle/profile.py

@@ -1,4 +1,21 @@
-"""Worktree Lifecycle profile loading and low-level git operations."""
+"""Worktree Lifecycle profile loading and low-level git operations.
+
+The profile carries **structural facts only** — worktree root, naming
+templates, the protected branches, the setup sequence. Deletion policy has
+exactly one configuration surface, the ignore mechanism, so no pattern list is
+read here. Keys this loader does not know are ignored in silence: a profile
+written for an older kit keeps working, and an obsolete key produces no warning
+noise.
+
+Two branch templates exist because two kinds of work land. `branchTemplate`
+names the branch of an issue-anchored slice; `contentBranchTemplate` names the
+issue-less branch a session cuts for durable content, so it renders `{type}`
+and `{slug}` only and refuses `{issue}` outright rather than inventing a number.
+
+`DEFAULT_MAIN_BRANCHES` is the single place in the kit that names an
+integration branch at all; every command, test, and message resolves the name
+through the profile instead of assuming it.
+"""
 
 from __future__ import annotations
 
@@ -9,6 +26,9 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
+DEFAULT_MAIN_BRANCHES = ("main", "master")
+DEFAULT_CONTENT_BRANCH_TEMPLATE = "{type}/{slug}"
+
 
 class LifecycleError(RuntimeError):
     """A safe, user-visible lifecycle refusal."""
@@ -18,6 +38,7 @@ class LifecycleError(RuntimeError):
 class WorktreeProfile:
     root: str
     branch_template: str
+    content_branch_template: str
     path_template: str
     main_branches: tuple[str, ...]
     protected_branches: tuple[str, ...]
@@ -25,15 +46,16 @@ class WorktreeProfile:
     branch_regex: str
     setup_entry: str
     risky_command_patterns: tuple[str, ...]
-    scratch_patterns: tuple[str, ...]
-    landing_generated_artifact_policy_configured: bool
-    landing_generated_artifact_patterns: tuple[str, ...]
 
     def branch_name(self, issue: str, slug: str, branch_type: str) -> str:
-        return _render(self.branch_template, issue, slug, branch_type)
+        return _render(self.branch_template, issue=issue, slug=slug, type=branch_type)
+
+    def content_branch_name(self, slug: str, branch_type: str) -> str:
+        """Name the issue-less branch of a Content-route session."""
+        return render_content_branch(self.content_branch_template, slug, branch_type)
 
     def relative_path(self, issue: str, slug: str, branch_type: str) -> Path:
-        name = _render(self.path_template, issue, slug, branch_type)
+        name = _render(self.path_template, issue=issue, slug=slug, type=branch_type)
         return Path(self.root) / name
 
     def issue_from_branch(self, branch: str) -> str | None:
@@ -41,14 +63,25 @@ class WorktreeProfile:
         return match.groupdict().get("issue") if match else None
 
 
-def _render(template: str, issue: str, slug: str, branch_type: str) -> str:
-    values = {"issue": issue, "slug": slug, "type": branch_type}
+def _render(template: str, **values: str) -> str:
+    """Render a profile template from exactly the placeholders it may use."""
     try:
         return template.format(**values)
-    except (KeyError, ValueError) as error:
+    except (KeyError, IndexError, ValueError) as error:
         raise LifecycleError(f"invalid worktree template: {error}") from error
 
 
+def render_content_branch(template: str, slug: str, branch_type: str) -> str:
+    """Render one issue-less content branch name — the placeholder policy's home.
+
+    A caller that reads the template out of a raw profile document (wrapup's
+    Content route does, because it must work whether or not the worktree
+    lifecycle itself is enabled) renders it here, so `{issue}` is refused in
+    exactly one place instead of two.
+    """
+    return _render(template, slug=slug, type=branch_type)
+
+
 def _load_profile_document(document: Any) -> WorktreeProfile:
     try:
         raw = document["worktreeLifecycle"]
@@ -56,26 +89,13 @@ def _load_profile_document(document: Any) -> WorktreeProfile:
         raise LifecycleError(f"cannot load worktree lifecycle profile: {error}") from error
     if raw.get("enabled") is not True:
         raise LifecycleError("worktree lifecycle is not enabled")
-    wrapup = document.get("wrapup")
-    if wrapup is None:
-        wrapup = {}
-    if not isinstance(wrapup, dict):
-        raise LifecycleError("invalid wrapup profile")
-    generated_policy_configured = "landingGeneratedArtifactPatterns" in wrapup
-    generated_patterns = (
-        wrapup["landingGeneratedArtifactPatterns"]
-        if generated_policy_configured
-        else ()
-    )
-    if (
-        not isinstance(generated_patterns, (list, tuple))
-        or not all(isinstance(pattern, str) and pattern for pattern in generated_patterns)
-    ):
-        raise LifecycleError("invalid wrapup landingGeneratedArtifactPatterns")
-    main = tuple(raw.get("mainBranches") or ("main", "master"))
+    main = tuple(raw.get("mainBranches") or DEFAULT_MAIN_BRANCHES)
     return WorktreeProfile(
         root=raw.get("worktreeRoot", ".worktrees"),
         branch_template=raw.get("branchTemplate", "{type}/{issue}-{slug}"),
+        content_branch_template=raw.get(
+            "contentBranchTemplate", DEFAULT_CONTENT_BRANCH_TEMPLATE,
+        ),
         path_template=raw.get("pathTemplate", "{type}-{issue}-{slug}"),
         main_branches=main,
         protected_branches=tuple(raw.get("protectedBranches") or main),
@@ -92,9 +112,6 @@ def _load_profile_document(document: Any) -> WorktreeProfile:
             r"\b(?:npm|pnpm|yarn)\s+(?:run\s+)?(?:test|typecheck|build)\b",
             r"\bgit\s+(?:commit|push)\b",
         )),
-        scratch_patterns=tuple(raw.get("scratchPatterns") or ()),
-        landing_generated_artifact_policy_configured=generated_policy_configured,
-        landing_generated_artifact_patterns=tuple(generated_patterns),
     )
 
 

package/scripts/worktree-lifecycle/setup.py

@@ -10,9 +10,6 @@ import zlib
 from pathlib import Path
 
 from core import (
-    BaselineBackfillDeferred,
-    capture_artifact_baseline,
-    ensure_artifact_baseline,
     LifecycleError,
     load_profile,
     local_branch_exists,
@@ -25,7 +22,9 @@ from core import (
 def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser()
     parser.add_argument("--profile", default="docs/agents/workflow-capabilities.json")
-    parser.add_argument("--base", default="origin/main")
+    # Resolved from the consumer profile when omitted — the integration
+    # branch is never named inline.
+    parser.add_argument("--base")
     parser.add_argument("issue")
     parser.add_argument("slug")
     parser.add_argument("branch_type", nargs="?", default="feat")
@@ -133,34 +132,24 @@ def create(args: argparse.Namespace) -> Path:
     if not profile_path.is_absolute():
         profile_path = main / profile_path
     profile = load_profile(profile_path)
+    base = args.base or f"origin/{profile.main_branches[0]}"
     branch = profile.branch_name(args.issue, args.slug, args.branch_type)
     target = (main / profile.relative_path(args.issue, args.slug, args.branch_type)).resolve()
 
     if target in registered_worktrees(main):
         ensure_reusable_base(
-            main, repo=target, rev="HEAD", base=args.base, label=f"worktree {target}"
+            main, repo=target, rev="HEAD", base=base, label=f"worktree {target}"
         )
-        try:
-            ensure_artifact_baseline(
-                target,
-                reject_ignored_patterns=profile.landing_generated_artifact_patterns,
-            )
-        except BaselineBackfillDeferred as error:
-            print(
-                "Baseline backfill deferred; preserve the worktree, remove generated "
-                f"blockers or commit/stash tracked work, then retry: {error}",
-                file=sys.stderr,
-            )
         print(f"Worktree already exists: {target} ({branch})")
         return target
 
     branch_existed = local_branch_exists(main, branch)
     if branch_existed:
         ensure_reusable_base(
-            main, repo=main, rev=branch, base=args.base, label=f"branch {branch}"
+            main, repo=main, rev=branch, base=base, label=f"branch {branch}"
         )
     command = ["git", "worktree", "add", str(target)]
-    command += [branch] if branch_existed else ["-b", branch, args.base]
+    command += [branch] if branch_existed else ["-b", branch, base]
     run(command, cwd=main)
     try:
         for step in profile.setup_steps:
@@ -171,7 +160,6 @@ def create(args: argparse.Namespace) -> Path:
                 issue=args.issue,
                 branch=branch,
             )
-        capture_artifact_baseline(target)
     except Exception:
         remove_failed_worktree(main, target, branch, not branch_existed)
         raise