@blxzer/cursor-trellis 0.1.0 → 0.1.2

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

@@ -7,12 +7,16 @@ from __future__ import annotations
 
 import argparse
 import json
+import sys
 from pathlib import Path
 
 from common.codebase_retrieval_router import (
     codebase_retrieval_selected_from_capabilities,
     route_codebase_retrieval,
 )
+from common.paths import get_repo_root
+from common.project_file_stats import resolve_project_file_count_arg
+from common.retrieval_agent_instructions import render_agent_instructions
 
 
 def load_capabilities(path: Path | None) -> dict[str, object] | None:
@@ -38,16 +42,24 @@ def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
         help="Treat codebase-retrieval as unselected (omit optional adapter routes).",
     )
     parser.add_argument(
-        "--platform",
-        default="generic",
-        choices=["cursor", "claude-code", "codex", "generic"],
-        help="Host platform for platform-adaptive routing (default: generic).",
+        "--project-file-count",
+        default="auto",
+        metavar="N|auto",
+        help=(
+            "File count for large-repo routing (>2000 promotes codegraph). "
+            "Default auto: git ls-files or walk from repo root. Example: 5000."
+        ),
     )
     parser.add_argument(
-        "--project-file-count",
-        type=int,
-        default=None,
-        help="Total file count in project for token economy signals (e.g. 5000).",
+        "--locale",
+        default="zh",
+        choices=["zh", "en"],
+        help="Language for agent instructions (default: zh).",
+    )
+    parser.add_argument(
+        "--instructions",
+        action="store_true",
+        help="Print agent-executable instructions only (no JSON).",
     )
     parser.add_argument("--json", action="store_true", help="Emit JSON to stdout (default).")
     parser.add_argument("--pretty", action="store_true", help="Pretty-print JSON.")
@@ -56,6 +68,14 @@ def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
 
 def main(argv: list[str] | None = None) -> int:
     args = parse_args(argv)
+    try:
+        project_file_count = resolve_project_file_count_arg(
+            args.project_file_count,
+            repo_root=get_repo_root(),
+        )
+    except ValueError as error:
+        print(f"route_codebase_retrieval: {error}", file=sys.stderr)
+        return 2
     caps = load_capabilities(Path(args.capabilities) if args.capabilities else None)
     selected = (
         False
@@ -65,11 +85,18 @@ def main(argv: list[str] | None = None) -> int:
     plan = route_codebase_retrieval(
         args.query,
         codebase_retrieval_selected=selected,
-        platform=args.platform,
-        project_file_count=args.project_file_count,
+        project_file_count=project_file_count,
+    )
+    instructions = render_agent_instructions(
+        plan,
+        locale=args.locale,
     )
+    if args.instructions:
+        sys.stdout.write(instructions)
+        return 0
+    payload: dict[str, object] = {**plan, "agentInstructions": instructions}
     indent = 2 if args.pretty else None
-    print(json.dumps(plan, indent=indent, ensure_ascii=False))
+    print(json.dumps(payload, indent=indent, ensure_ascii=False))
     return 0
 
 

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

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""REC-11: derive evidence_score (0-2) from telemetry + optional rubric row."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+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.retrieval_tool_classification import classify_tool_calls  # noqa: E402
+
+
+def evidence_score_from_record(record: dict[str, Any]) -> int:
+    """
+    Trellis verified layer proxy for eval (R-CR-014):
+    0 = no Read on candidates
+    1 = Read used but no corroborated_files / weak verify
+    2 = read_verification_done and (corroborated_files or read_count >= 1 with top1)
+    """
+    if not record.get("read_verification_done") and int(record.get("read_count") or 0) <= 0:
+        return 0
+    corroborated = record.get("corroborated_files") or []
+    if isinstance(corroborated, list) and len(corroborated) > 0:
+        return 2
+    if record.get("read_verification_done") or int(record.get("read_count") or 0) > 0:
+        top1 = str(record.get("top1") or record.get("top_1") or "").strip()
+        if top1:
+            return 2
+        return 1
+    return 0
+
+
+def enrich_record(raw: dict[str, Any]) -> dict[str, Any]:
+    platform = str(raw.get("platform", "cursor"))
+    tools = raw.get("tools_called") or []
+    if not isinstance(tools, list):
+        tools = []
+    classified = classify_tool_calls([str(t) for t in tools], platform=platform)
+    out = dict(raw)
+    out["platform_semantic_executed"] = bool(
+        raw.get("platform_semantic_executed", classified.platform_semantic_executed)
+    )
+    out["semantic_executed"] = bool(raw.get("semantic_executed", classified.semantic_executed))
+    out["read_count"] = int(raw.get("read_count", classified.read_count))
+    if "read_verification_done" not in out:
+        out["read_verification_done"] = classified.read_count > 0
+    out["evidence_score"] = evidence_score_from_record(out)
+    ans = raw.get("answer_score")
+    if isinstance(ans, (int, float)):
+        out["combined_score"] = float(ans) + float(out["evidence_score"])
+    return out
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("jsonl", type=Path, help="Per-query telemetry JSONL")
+    parser.add_argument("--pretty", action="store_true")
+    parser.add_argument("--markdown", action="store_true")
+    args = parser.parse_args(argv)
+
+    if not args.jsonl.is_file():
+        print(f"error: not found: {args.jsonl}", file=sys.stderr)
+        return 1
+
+    rows: list[dict[str, Any]] = []
+    for line in args.jsonl.read_text(encoding="utf-8").splitlines():
+        stripped = line.strip()
+        if not stripped:
+            continue
+        raw = json.loads(stripped)
+        if isinstance(raw, dict):
+            rows.append(enrich_record(raw))
+
+    evidence_total = sum(int(r.get("evidence_score", 0)) for r in rows)
+    combined: list[float] = []
+    for r in rows:
+        c = r.get("combined_score")
+        if isinstance(c, (int, float)):
+            combined.append(float(c))
+
+    summary = {
+        "n": len(rows),
+        "evidence_score_total": evidence_total,
+        "evidence_score_max": len(rows) * 2,
+        "avg_evidence_score": 0.0 if not rows else evidence_total / len(rows),
+        "avg_combined_score": 0.0 if not combined else sum(combined) / len(combined),
+    }
+
+    if args.markdown:
+        print("## Evidence scores (REC-11)\n")
+        print("| query_id | evidence_score | read_verify | semantic_exec |")
+        print("| --- | ---: | --- | --- |")
+        for r in rows:
+            print(
+                f"| {r.get('query_id','')} | {r.get('evidence_score',0)} | "
+                f"{r.get('read_verification_done')} | {r.get('semantic_executed')} |"
+            )
+        print(f"\nTotal evidence: **{evidence_total}** / {summary['evidence_score_max']}")
+    else:
+        payload = {"summary": summary, "records": rows}
+        print(json.dumps(payload, ensure_ascii=False, indent=2 if args.pretty else None))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -28,6 +28,7 @@ Usage:
     python task.py set-child-state <parent-dir> <child-dir> <state> --evidence <ref>
     python task.py integrate-child <parent-dir> <child-dir> <state> --evidence <ref>
     python task.py generate-child-prompt <parent-dir> <child-dir> [--mode inline|subagent]
+    python task.py generate-dispatch-prompt <task-dir> <role> [--scope TEXT] [--finish] [--max-chars N]
     python task.py parent-status <parent-dir>
     python task.py review-child <parent-dir> <child-dir> [--check] [--decision accept|changes|cancel|integrate-through]
 """
@@ -90,6 +91,7 @@ from common.task_store import (
     cmd_set_child_state,
     cmd_integrate_child,
     cmd_generate_child_prompt,
+    cmd_generate_dispatch_prompt,
     cmd_parent_status,
     cmd_review_child,
 )
@@ -750,6 +752,29 @@ def main() -> int:
     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("--check", action="store_true", help="Run non-mutating integration readiness check")
 
+    # generate-dispatch-prompt
+    p_dispatch_prompt = subparsers.add_parser(
+        "generate-dispatch-prompt",
+        help="Build full Task dispatch prompt (Agent-facing)",
+    )
+    p_dispatch_prompt.add_argument("task_dir", help="Task directory")
+    p_dispatch_prompt.add_argument(
+        "role",
+        choices=["implement", "check", "research"],
+        help="Subagent role",
+    )
+    p_dispatch_prompt.add_argument("--scope", help="One-line task instruction for subagent")
+    p_dispatch_prompt.add_argument(
+        "--finish",
+        action="store_true",
+        help="Use finish check context (role=check only)",
+    )
+    p_dispatch_prompt.add_argument(
+        "--max-chars",
+        type=int,
+        help="Hard truncate embedded context block",
+    )
+
     # generate-child-prompt
     p_gen_prompt = subparsers.add_parser(
         "generate-child-prompt",
@@ -834,6 +859,7 @@ def main() -> int:
         "set-child-state": cmd_set_child_state,
         "integrate-child": cmd_integrate_child,
         "generate-child-prompt": cmd_generate_child_prompt,
+        "generate-dispatch-prompt": cmd_generate_dispatch_prompt,
         "parent-status": cmd_parent_status,
         "review-child": cmd_review_child,
         "list": cmd_list,