@blxzer/cursor-trellis 0.3.5 → 0.3.6

package/dist/templates/trellis/scripts/common/test_observable_defaults.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+"""Tests for P1 observable defaults (verify seed, jsonl seed, dashboard summary)."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from common.artifact_locale import default_verify_content
+from common.task_dashboard import format_verify_summary, render_task_dashboard
+from common.task_store import _resolve_seed_spec_paths, _write_seed_jsonl
+
+
+def test_default_verify_content_has_standard_sections() -> None:
+    content = default_verify_content(locale="en")
+    for heading in (
+        "## Planning check",
+        "## Execution evidence",
+        "### Validation commands",
+        "### Acceptance",
+        "### Durable learning",
+    ):
+        assert heading in content
+
+
+def test_write_seed_jsonl_uses_real_spec_paths(tmp_path: Path) -> None:
+    repo_root = tmp_path / "repo"
+    spec_root = repo_root / ".cstl" / "spec" / "guides"
+    spec_root.mkdir(parents=True)
+    for name in ("index.md", "verification-strength-guide.md", "injection-budget-guide.md"):
+        (spec_root / name).write_text(f"# {name}\n", encoding="utf-8")
+
+    task_dir = repo_root / ".cstl" / "tasks" / "08-07-test-seed"
+    task_dir.mkdir(parents=True)
+    task_data = {"id": "test-seed", "package": None, "scope": None, "children": []}
+
+    jsonl_path = task_dir / "implement.jsonl"
+    _write_seed_jsonl(jsonl_path, repo_root, task_dir, task_data)
+
+    rows = [json.loads(line) for line in jsonl_path.read_text(encoding="utf-8").splitlines() if line.strip()]
+    assert len(rows) >= 2
+    assert all("file" in row and row["file"].startswith(".cstl/spec/") for row in rows)
+    assert all("_example" not in row for row in rows)
+    for row in rows:
+        assert (repo_root / row["file"]).is_file()
+
+
+def test_resolve_seed_spec_paths_prefers_existing_guides(tmp_path: Path) -> None:
+    repo_root = tmp_path / "repo"
+    guides = repo_root / ".cstl" / "spec" / "guides"
+    guides.mkdir(parents=True)
+    (guides / "index.md").write_text("# index\n", encoding="utf-8")
+    (guides / "verification-strength-guide.md").write_text("# verify\n", encoding="utf-8")
+
+    task_dir = repo_root / ".cstl" / "tasks" / "08-07-test-paths"
+    task_dir.mkdir(parents=True)
+    paths = _resolve_seed_spec_paths(repo_root, task_dir, {"children": []})
+    assert len(paths) >= 2
+    assert all((repo_root / rel).is_file() for rel in paths)
+
+
+def test_format_verify_summary_missing_without_file(tmp_path: Path) -> None:
+    task_dir = tmp_path / "task"
+    task_dir.mkdir()
+    assert format_verify_summary(task_dir, {"children": []}) == "[verify: missing]"
+
+
+def test_format_verify_summary_partial_from_signals(tmp_path: Path) -> None:
+    task_dir = tmp_path / "task"
+    task_dir.mkdir()
+    (task_dir / "verify.md").write_text(
+        "Validation commands: pytest -q — pass\n",
+        encoding="utf-8",
+    )
+    assert format_verify_summary(task_dir, {"children": []}) == "[verify: partial]"
+
+
+def test_format_verify_summary_ok_when_all_signals(tmp_path: Path) -> None:
+    task_dir = tmp_path / "task"
+    task_dir.mkdir()
+    (task_dir / "verify.md").write_text(
+        "\n".join(
+            [
+                "Validation commands: pytest -q — pass",
+                "Check evidence: cstl-check — pass",
+                "Final acceptance evidence: all AC met",
+                "Durable learning decision: no durable learning",
+                "Reviewed change-set: git diff main..HEAD",
+            ]
+        ),
+        encoding="utf-8",
+    )
+    assert format_verify_summary(task_dir, {"children": []}) == "[verify: ok]"
+
+
+def test_render_task_dashboard_includes_verify_summary(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    repo_root = tmp_path / "repo"
+    tasks_dir = repo_root / ".cstl" / "tasks"
+    task_dir = tasks_dir / "08-07-dashboard-task"
+    task_dir.mkdir(parents=True)
+    (task_dir / "task.json").write_text(
+        json.dumps(
+            {
+                "id": "dashboard-task",
+                "name": "dashboard-task",
+                "title": "dashboard-task",
+                "status": "planning",
+                "assignee": "dev",
+                "children": [],
+            }
+        ),
+        encoding="utf-8",
+    )
+    (task_dir / "verify.md").write_text(
+        "Validation commands: echo ok — pass\n",
+        encoding="utf-8",
+    )
+
+    monkeypatch.chdir(repo_root)
+    monkeypatch.setattr("common.task_dashboard.get_repo_root", lambda: repo_root)
+    monkeypatch.setattr("common.task_dashboard.get_tasks_dir", lambda _root=None: tasks_dir)
+    monkeypatch.setattr("common.task_dashboard.get_developer", lambda _root=None: "dev")
+    monkeypatch.setattr(
+        "common.active_task.resolve_selected_task",
+        lambda *_args, **_kwargs: type("Sel", (), {"task_path": None, "source": None})(),
+    )
+
+    dashboard = render_task_dashboard(repo_root)
+    assert "[verify: partial]" in dashboard
+    assert "08-07-dashboard-task" in dashboard

package/dist/templates/trellis/scripts/cursor_retrieval_probe_prompt.md

@@ -251,36 +251,38 @@ verdict rules:
 
 ---
 
---- PROBE P-10: Definition / reference (codegraph — Agent LSP not exposed)
+--- PROBE P-10: Definition / reference (Prefer Grep+Read; codegraph when ambiguous)
 
 Cursor Agent does **not** expose GO_TO_DEFINITION in the tool table (Native/BYOK).
-Trellis routes definition/reference to **codegraph**. This probe measures the
-**product path**, not raw LSP.
+Trellis **Prefers** native **Grep → Read** for named-symbol definition; **codegraph**
+is the **Own** fallback when Grep is ambiguous or structural context is required.
 
-You are a retrieval capability probe. Use **codegraph_node** or **codegraph_search**
-as the **primary** path. Do NOT use Grep as the first step. Use **Read** only to
-confirm line numbers after codegraph returns a definition.
+You are a retrieval capability probe.
 
 Task: Locate the **definition** of `route_codebase_retrieval` (Python function).
 
+**Step 1 (Prefer):** Use **Grep** for `def route_codebase_retrieval` — do NOT use codegraph first.
+**Step 2:** Use **Read** to confirm the definition line and body start.
+**Step 3 (only if Grep ambiguous):** codegraph_explore / codegraph_search.
+
 Expected: definition in `.cstl/scripts/common/codebase_retrieval_router.py`
-(`def route_codebase_retrieval(`).
+(`def route_codebase_retrieval(` at line ~805).
 
 Reply in this exact format:
 
 ```
 P-10 RESULT
-tool_invoked: <exact tool name — codegraph_node, codegraph_search, or "none">
+tool_invoked: <primary tool — Grep, Read, codegraph_explore, or "none">
 definition_file: <path>
 definition_line: <line number or "unknown">
 verdict: pass|fail|environment_limitation
-notes: <if you tried GO_TO_DEFINITION and it was unavailable, say so; pass when codegraph + Read confirm def>
+notes: <GO_TO_DEFINITION availability; did Grep+Read succeed before any codegraph?>
 ```
 
 verdict rules:
-- **pass**: codegraph (or equivalent MCP) returned the correct `def route_codebase_retrieval` file.
-- **environment_limitation**: only when codegraph MCP/index is missing; not when LSP is missing.
-- **fail**: wrong file or no structural tool executed.
+- **pass**: Grep (+ Read) returned the correct `def route_codebase_retrieval` file; codegraph optional.
+- **environment_limitation**: only when Grep/Read are unavailable in the host (not when LSP is missing).
+- **fail**: wrong file, or codegraph used as first step without Grep attempt.
 
 ---
 

package/dist/templates/trellis/scripts/generate_dispatch_prompt.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+"""
+CLI Layer 2 — PRIMARY (guaranteed) context path for cstl-* Task dispatch.
+
+Usage:
+    python ./.cstl/scripts/generate_dispatch_prompt.py --agent research
+    python ./.cstl/scripts/generate_dispatch_prompt.py --agent implement --task .cstl/tasks/06-23-subagent-smoke
+    python ./.cstl/scripts/generate_dispatch_prompt.py --agent research --repo-root d:/MyHarness
+
+Outputs the complete dispatch prompt to stdout. The main session MUST capture
+this output and pass it as the `prompt` parameter to
+`Task(subagent_type=cstl-*, prompt=<generated>)`. This is the ONLY
+guaranteed context channel for custom Task subagents on Cursor.
+
+Hook injection (`preToolUse` / `additional_context`) is best-effort only
+(Cursor #158452; hook does not fire for Task tool in Cursor 3.8.22). Do not
+treat hook-only injection as a substitute for this CLI path.
+
+The generated prompt carries:
+  - Role identity ("You are the Trellis Research/Implement/Check Agent")
+  - Write scope constraints (Write ALLOWED / Write FORBIDDEN)
+  - Recursion guard
+  - Dynamic context (prd.md, design.md, implement.md, spec tree, jsonl files)
+
+Task path resolution:
+  - `--task <path>` is the **primary fallback** when no selected-task pointer exists
+    (e.g. `task.py select` failed due to missing session identity).
+  - When `--task` is omitted, auto-detect via selected pointer is **best-effort** only —
+    dispatch scripts do not hard-depend on a persisted selection.
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Generate a complete Trellis subagent dispatch prompt."
+    )
+    parser.add_argument(
+        "--agent",
+        required=True,
+        choices=["research", "implement", "check"],
+        help="Subagent role to generate prompt for.",
+    )
+    parser.add_argument(
+        "--task",
+        default=None,
+        help="Task directory path (absolute or relative to repo root). "
+        "Primary fallback when no selected-task pointer exists. "
+        "If omitted, auto-detect via selected pointer is best-effort only.",
+    )
+    parser.add_argument(
+        "--repo-root",
+        default=None,
+        help="Repository root path. If omitted, auto-detect via .cstl or .git.",
+    )
+    parser.add_argument(
+        "--finish",
+        action="store_true",
+        help="Use finish context (check agent only, final pre-PR verification).",
+    )
+    parser.add_argument(
+        "--max-chars",
+        type=int,
+        default=None,
+        help="Truncate injected context at this character count. "
+        "When omitted, uses role default from injection-budget-guide.",
+    )
+    args = parser.parse_args()
+
+    # Resolve repo root
+    if args.repo_root:
+        repo_root = Path(args.repo_root).resolve()
+    else:
+        repo_root = _find_repo_root(Path.cwd())
+        if not repo_root:
+            print("ERROR: could not find repo root (no .cstl or .git upward)", file=sys.stderr)
+            return 1
+
+    from common.paths import DIR_WORKFLOW  # type: ignore[import-not-found]
+
+    # Make scripts importable — workspace root first (subagent_dispatch.py lives there),
+    # then repo_root's own scripts (may be a subproject with different common/)
+    workspace_root = _find_workspace_root(repo_root, DIR_WORKFLOW)
+    if workspace_root and workspace_root != repo_root:
+        ws_scripts = workspace_root / DIR_WORKFLOW / "scripts"
+        if str(ws_scripts) not in sys.path:
+            sys.path.insert(0, str(ws_scripts))
+
+    scripts_dir = repo_root / DIR_WORKFLOW / "scripts"
+    if str(scripts_dir) not in sys.path:
+        sys.path.insert(1, str(scripts_dir))
+
+    from common.subagent_dispatch import build_dispatch_prompt  # type: ignore[import-not-found]
+    from common.injection_budget import DISPATCH_DEFAULT_MAX_CHARS  # type: ignore[import-not-found]
+
+    # Resolve task directory
+    if args.task:
+        task_dir = Path(args.task)
+        if not task_dir.is_absolute():
+            task_dir = repo_root / task_dir
+        task_dir = task_dir.resolve()
+    else:
+        task_dir = _resolve_selected_task(repo_root)
+        if not task_dir:
+            print(
+                "ERROR: no --task specified and no selected task found. "
+                "Run `python ./.cstl/scripts/task.py select <task>` first.",
+                file=sys.stderr,
+            )
+            return 1
+
+    if not task_dir.is_dir():
+        print(f"ERROR: task directory not found: {task_dir}", file=sys.stderr)
+        return 1
+
+    max_chars = args.max_chars
+    if max_chars is None:
+        max_chars = DISPATCH_DEFAULT_MAX_CHARS.get(args.agent)
+
+    prompt, warnings, errors = build_dispatch_prompt(
+        repo_root,
+        task_dir,
+        args.agent,
+        finish=args.finish,
+        max_chars=max_chars,
+        require_in_progress=False,
+    )
+
+    for w in warnings:
+        print(f"WARN: {w}", file=sys.stderr)
+    for e in errors:
+        print(f"ERROR: {e}", file=sys.stderr)
+
+    if not prompt:
+        print("ERROR: failed to generate prompt (see errors above)", file=sys.stderr)
+        return 1
+
+    # Output the prompt to stdout — the caller captures this
+    print(prompt)
+    return 0
+
+
+def _find_repo_root(start: Path) -> Path | None:
+    current = start.resolve()
+    while current != current.parent:
+        if (current / ".cstl").is_dir() or (current / ".git").exists():
+            return current
+        current = current.parent
+    return None
+
+
+def _find_workspace_root(start: Path, dir_workflow: str) -> Path | None:
+    """Find the outermost directory with workflow dir (workspace root, not subproject)."""
+    found = None
+    current = start.resolve()
+    while current != current.parent:
+        if (current / dir_workflow).is_dir():
+            found = current
+        current = current.parent
+    return found
+
+
+def _resolve_selected_task(repo_root: Path) -> Path | None:
+    try:
+        from common.active_task import resolve_selected_task  # type: ignore[import-not-found]
+        result = resolve_selected_task(repo_root, {}, platform="cursor")
+        if result.task_path:
+            task_path = Path(result.task_path)
+            if not task_path.is_absolute():
+                task_path = repo_root / task_path
+            return task_path
+    except Exception:
+        pass
+    return None
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/dist/templates/trellis/scripts/injection_budget_probe.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+"""Injection budget probe — measure alwaysApply, AGENTS, jsonl, and Layer 2 dispatch."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+_SCRIPTS = Path(__file__).resolve().parent
+if str(_SCRIPTS) not in sys.path:
+    sys.path.insert(0, str(_SCRIPTS))
+
+from common.injection_budget import (  # noqa: E402
+    budget_violations,
+    collect_budget_report,
+    format_budget_report,
+)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Measure Trellis injection budget surfaces.")
+    parser.add_argument("--repo-root", default=".", help="Repository root (default: .)")
+    parser.add_argument("--task", default=None, help="Task directory for jsonl/dispatch probes")
+    parser.add_argument(
+        "--dispatch-role",
+        choices=["implement", "check", "research"],
+        default="implement",
+        help="Role when measuring dispatch prompt (default: implement)",
+    )
+    parser.add_argument(
+        "--strict",
+        action="store_true",
+        help="Exit 1 on FAIL thresholds (rules >32KiB) or any WARN",
+    )
+    parser.add_argument("--json", action="store_true", help="Reserved for future machine output")
+    args = parser.parse_args()
+
+    if args.json:
+        print("ERROR: --json not implemented yet", file=sys.stderr)
+        return 2
+
+    repo_root = Path(args.repo_root).resolve()
+    task_dir = None
+    if args.task:
+        task_dir = Path(args.task)
+        if not task_dir.is_absolute():
+            task_dir = repo_root / task_dir
+        task_dir = task_dir.resolve()
+
+    report = collect_budget_report(
+        repo_root,
+        task_dir=task_dir,
+        dispatch_role=args.dispatch_role if task_dir else None,
+    )
+    print(format_budget_report(report))
+
+    violations = budget_violations(report, strict=args.strict)
+    if violations:
+        print("\n## Violations", file=sys.stderr)
+        for item in violations:
+            print(item, file=sys.stderr)
+        if args.strict or any(item.startswith("FAIL:") for item in violations):
+            return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/dist/templates/trellis/scripts/retrieval_probe_matrix_template.json

@@ -85,11 +85,11 @@
     },
     {
       "id": "P-10",
-      "label": "Definition / reference via codegraph (LSP not in Agent tool table)",
+      "label": "Definition / reference — Prefer Grep+Read; codegraph when ambiguous",
       "nature": "local-mcp",
       "expected_byok": "pass",
-      "native": { "status": "pass", "evidence": "codegraph_search + node; def route_codebase_retrieval L791; GO_TO_DEFINITION none", "actual_tool": "codegraph_search", "probed_at": "2026-06-23" },
-      "byok":   { "status": "pass", "evidence": "codegraph_node at def route_codebase_retrieval; GO_TO_DEFINITION none", "actual_tool": "codegraph_node", "probed_at": "2026-06-23" }
+      "native": { "status": "pass", "evidence": "Grep def route_codebase_retrieval L805 codebase_retrieval_router.py; Read confirm; GO_TO_DEFINITION none; codegraph optional", "actual_tool": "Grep", "probed_at": "2026-08-05" },
+      "byok":   { "status": "pass", "evidence": "Grep+Read same as native; GO_TO_DEFINITION none", "actual_tool": "Grep", "probed_at": "2026-08-05" }
     },
     {
       "id": "P-08-SA",

package/dist/templates/trellis/scripts/spec_health_outcomes.py

@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+"""S1 spec-health outcomes — read-only durable-learning distribution over archive verify.md.
+
+Maintainer observability only — NOT a blocking gate or KPI.
+See .cstl/spec/guides/durable-learning-decision-guide.md for outcome definitions.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from collections import defaultdict
+from pathlib import Path
+from typing import Any
+
+_SCRIPT_DIR = Path(__file__).resolve().parent
+if str(_SCRIPT_DIR) not in sys.path:
+    sys.path.insert(0, str(_SCRIPT_DIR))
+
+from common.task_gates import NO_DURABLE_LEARNING_RE  # noqa: E402
+
+BUCKET_NAMES = ("no_only", "spec", "artifact", "ambiguous_multi", "legacy_none")
+
+MONTH_RE = re.compile(r"^(\d{4}-\d{2})$")
+
+
+def detect_signals(content: str) -> dict[str, bool]:
+    """Return which durable-learning signal families appear in verify.md text.
+
+    Uses the same substring probes as spec-health-signals.md S1 baseline (2026-08-06).
+    """
+    lower = content.lower()
+    return {
+        "no": bool(NO_DURABLE_LEARNING_RE.search(content)),
+        "spec": "spec update evidence" in lower,
+        "artifact": "learning artifact" in lower,
+    }
+
+
+def classify_bucket(content: str) -> str:
+    """Assign exactly one mutually-exclusive S1 outcome bucket."""
+    active = [name for name, present in detect_signals(content).items() if present]
+    if not active:
+        return "legacy_none"
+    if len(active) > 1:
+        return "ambiguous_multi"
+    return {"no": "no_only", "spec": "spec", "artifact": "artifact"}[active[0]]
+
+
+def extract_month(verify_path: Path, archive_root: Path) -> str | None:
+    """Derive YYYY-MM from archive folder layout (e.g. archive/2026-08/<task>/verify.md)."""
+    try:
+        rel = verify_path.relative_to(archive_root)
+    except ValueError:
+        return None
+    if rel.parts and MONTH_RE.match(rel.parts[0]):
+        return rel.parts[0]
+    return None
+
+
+def empty_counts() -> dict[str, int]:
+    return {name: 0 for name in BUCKET_NAMES}
+
+
+def scan_archive(root: Path) -> tuple[dict[str, int], dict[str, dict[str, int]], int]:
+    totals = empty_counts()
+    by_month: dict[str, dict[str, int]] = defaultdict(empty_counts)
+    total_files = 0
+
+    for verify_path in sorted(root.rglob("verify.md")):
+        if not verify_path.is_file():
+            continue
+        total_files += 1
+        try:
+            content = verify_path.read_text(encoding="utf-8")
+        except OSError:
+            content = ""
+        bucket = classify_bucket(content)
+        totals[bucket] += 1
+        month = extract_month(verify_path, root)
+        if month:
+            by_month[month][bucket] += 1
+
+    return totals, dict(sorted(by_month.items())), total_files
+
+
+def build_report(root: Path, *, by_month: bool) -> dict[str, Any]:
+    totals, monthly, total_files = scan_archive(root)
+    report: dict[str, Any] = {
+        "root": str(root),
+        "total": total_files,
+        "buckets": totals,
+        "note": "Maintainer observability only — not a blocking gate or KPI.",
+    }
+    if by_month:
+        report["by_month"] = monthly
+    return report
+
+
+def format_text_report(report: dict[str, Any]) -> str:
+    lines = [
+        f"Spec health S1 outcomes — {report['total']} verify.md files",
+        f"Root: {report['root']}",
+        "",
+    ]
+    total = int(report["total"])
+    for name in BUCKET_NAMES:
+        count = int(report["buckets"][name])
+        pct = (count / total * 100) if total else 0.0
+        lines.append(f"  {name}: {count} ({pct:.1f}%)")
+    lines.extend(["", str(report["note"])])
+    if report.get("by_month"):
+        lines.append("")
+        lines.append("By month:")
+        for month, counts in report["by_month"].items():
+            month_total = sum(int(v) for v in counts.values())
+            lines.append(f"  {month}: {month_total} files — {counts}")
+    return "\n".join(lines)
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        description=(
+            "S1 spec-health: durable-learning outcome distribution in archive verify.md "
+            "(read-only; not a gate)."
+        ),
+    )
+    parser.add_argument(
+        "--root",
+        type=Path,
+        default=Path(".cstl/tasks/archive"),
+        help="Archive root to scan (default: .cstl/tasks/archive)",
+    )
+    parser.add_argument("--json", action="store_true", help="Emit JSON report on stdout")
+    parser.add_argument(
+        "--by-month",
+        action="store_true",
+        help="Include per YYYY-MM bucket counts (from archive folder names)",
+    )
+    args = parser.parse_args(argv)
+
+    root = args.root.resolve()
+    if not root.is_dir():
+        print(f"error: archive root not found: {root}", file=sys.stderr)
+        return 1
+
+    report = build_report(root, by_month=args.by_month)
+
+    if args.json:
+        print(json.dumps(report, indent=2, ensure_ascii=False))
+    else:
+        print(format_text_report(report))
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/dist/templates/trellis/scripts/task.py

@@ -97,6 +97,7 @@ from common.task_store import (
     cmd_parent_status,
     cmd_publish_pack,
     cmd_review_child,
+    cmd_artifact_locale,
 )
 from common.task_context import (
     cmd_add_context,
@@ -707,6 +708,18 @@ def main() -> int:
     p_scope.add_argument("dir", help="Task directory")
     p_scope.add_argument("scope", help="Scope name")
 
+    # artifact-locale
+    p_artifact_locale = subparsers.add_parser(
+        "artifact-locale",
+        help="Get or set human-reviewed artifact locale (zh | en)",
+    )
+    locale_sub = p_artifact_locale.add_subparsers(dest="artifact_locale_command")
+    p_locale_get = locale_sub.add_parser("get", help="Print resolved artifact locale")
+    p_locale_get.add_argument("--task", help="Task directory (includes task override)")
+    p_locale_set = locale_sub.add_parser("set", help="Set artifact locale")
+    p_locale_set.add_argument("locale", choices=["zh", "en"], help="Locale code")
+    p_locale_set.add_argument("--task", help="Task directory (task-level override)")
+
     # archive
     p_archive = subparsers.add_parser("archive", help="Archive task")
     p_archive.add_argument("name", help="Task directory or name")
@@ -782,6 +795,11 @@ def main() -> int:
     p_integrate_child.add_argument("--ref", help="Child git ref or reviewed diff reference")
     p_integrate_child.add_argument("--reason", help="Optional short reason")
     p_integrate_child.add_argument("--execute-merge", action="store_true", help="Execute git merge --no-ff --no-commit for an integrated Child")
+    p_integrate_child.add_argument(
+        "--no-publish-pack",
+        action="store_true",
+        help="Skip auto publish-pack after integrated (default: refresh child-prompts/ including evidence-only integrates)",
+    )
     p_integrate_child.add_argument("--check", action="store_true", help="Run non-mutating integration readiness check")
 
     # suggest-execution-strategy
@@ -935,6 +953,7 @@ def main() -> int:
         "parent-status": cmd_parent_status,
         "publish-pack": cmd_publish_pack,
         "review-child": cmd_review_child,
+        "artifact-locale": cmd_artifact_locale,
         "list": cmd_list,
         "list-archive": cmd_list_archive,
     }

package/dist/templates/trellis/tasks/locale/en/default-prd.md

@@ -0,0 +1,19 @@
+# {title}
+
+## Goal
+
+{goal}
+
+## Requirements
+
+- TBD
+
+## Acceptance Criteria
+
+- [ ] TBD
+
+## Notes
+
+- Keep `prd.md` focused on requirements, constraints, and acceptance criteria.
+- Lightweight tasks can remain PRD-only.
+- For complex tasks, add `design.md` for technical design and `implement.md` for execution planning before `task.py start-execution --check`.