Add signal-targeted intrinsic raw variant expansion (sprint 260)

tools/mcp/run_sprint_taskitem_pipeline.sh

@@ -53,6 +53,8 @@ NATIVE_RAW_CANDIDATE_SEARCH="${WSTONE_NATIVE_RAW_CANDIDATE_SEARCH:-0}"
 NATIVE_RAW_CANDIDATE_MAX_VARIANTS="${WSTONE_NATIVE_RAW_CANDIDATE_MAX_VARIANTS:-8}"
 NATIVE_RAW_CANDIDATE_REQUIRE_UPLIFT="${WSTONE_NATIVE_RAW_CANDIDATE_REQUIRE_UPLIFT:-0}"
 NATIVE_RAW_HARDEN_TOP_GAPS="${WSTONE_NATIVE_RAW_HARDEN_TOP_GAPS:-0}"
+NATIVE_RAW_SIGNAL_TARGETED_VARIANTS="${WSTONE_NATIVE_RAW_SIGNAL_TARGETED_VARIANTS:-0}"
+NATIVE_RAW_SIGNAL_TARGETED_MAX_VARIANTS="${WSTONE_NATIVE_RAW_SIGNAL_TARGETED_MAX_VARIANTS:-6}"
 NATIVE_RAW_TOP_GAP_WEIGHTED_SELECT="${WSTONE_NATIVE_RAW_TOP_GAP_WEIGHTED_SELECT:-0}"
 NATIVE_RAW_TOP_GAP_BACKLOG_FILE="${WSTONE_NATIVE_RAW_TOP_GAP_BACKLOG_FILE:-}"
 NATIVE_RAW_TOP_GAP_REQUIRE_UPLIFT="${WSTONE_NATIVE_RAW_TOP_GAP_REQUIRE_UPLIFT:-0}"
@@ -123,6 +125,7 @@ NATIVE_SINGLESHOT_PROFILE_SHAPE_JSON='{}'
 NATIVE_MULTISHOT_JSON='{}'
 NATIVE_RAW_CANDIDATE_SEARCH_JSON='{}'
 NATIVE_RAW_HARDENING_JSON='{}'
+NATIVE_RAW_SIGNAL_TARGETED_VARIANTS_JSON='{}'
 NATIVE_RAW_TOP_GAP_REQUIREMENTS_JSON='{}'
 NATIVE_RAW_ADAPTIVE_RETRY_JSON='{}'
 INTRINSIC_REQS_JSON='[]'
@@ -429,6 +432,24 @@ if [[ "$NATIVE_RAW_CANDIDATE_SEARCH" == "1" ]]; then
     --max-variants "$NATIVE_RAW_CANDIDATE_MAX_VARIANTS" \
     --out "$OUT_DIR/02ae_raw_candidate_variants.json" >/dev/null
   VARIANTS_JSON="$(cat "$OUT_DIR/02ae_raw_candidate_variants.json")"
+  if [[ "$NATIVE_RAW_SIGNAL_TARGETED_VARIANTS" == "1" && -n "$NATIVE_RAW_TOP_GAP_BACKLOG_FILE" && -f "$NATIVE_RAW_TOP_GAP_BACKLOG_FILE" ]]; then
+    python3 "$ROOT_DIR/tools/mcp/synthesize_raw_signal_targeted_variants.py" \
+      --top-gaps "$NATIVE_RAW_TOP_GAP_BACKLOG_FILE" \
+      --max-variants "$NATIVE_RAW_SIGNAL_TARGETED_MAX_VARIANTS" \
+      --out "$OUT_DIR/02ae_raw_signal_targeted_variants.json" >/dev/null
+    signal_variants_count="$(jq '.variant_count // 0' "$OUT_DIR/02ae_raw_signal_targeted_variants.json")"
+    VARIANTS_JSON="$(jq -nc \
+      --argjson base "$VARIANTS_JSON" \
+      --argjson sig "$(cat "$OUT_DIR/02ae_raw_signal_targeted_variants.json")" \
+      '{status:"ok", active_profile_count:($base.active_profile_count // 0), variant_count:(((($base.variants // [])|length) + (($sig.variants // [])|length))), variants:(($base.variants // []) + ($sig.variants // []))}')"
+    NATIVE_RAW_SIGNAL_TARGETED_VARIANTS_JSON="$(jq -nc \
+      --argjson enabled true \
+      --arg backlog_file "$NATIVE_RAW_TOP_GAP_BACKLOG_FILE" \
+      --argjson variant_count "$signal_variants_count" \
+      '{enabled:$enabled, backlog_file:$backlog_file, variant_count:$variant_count}')"
+  else
+    NATIVE_RAW_SIGNAL_TARGETED_VARIANTS_JSON='{"enabled":false}'
+  fi
 
   printf '%s\n' "$TASKS" > "$OUT_DIR/02ae_candidate_0_tasks.json"
   python3 "$ROOT_DIR/tools/mcp/score_native_tasks_profile_coverage.py" \
@@ -589,6 +610,7 @@ if [[ "$NATIVE_RAW_CANDIDATE_SEARCH" == "1" ]]; then
   fi
 else
   NATIVE_RAW_CANDIDATE_SEARCH_JSON='{"enabled":false}'
+  NATIVE_RAW_SIGNAL_TARGETED_VARIANTS_JSON='{"enabled":false}'
 fi
 if [[ "$NATIVE_RAW_HARDEN_TOP_GAPS" == "1" ]]; then
   printf '%s\n' "$TASKS" > "$OUT_DIR/02af_raw_hardening_input_tasks.json"
@@ -934,6 +956,7 @@ SUMMARY_JSON="$(jq -nc \
   --argjson native_profile_autofill "$NATIVE_PROFILE_AUTOFILL_JSON" \
   --argjson native_intrinsic_boost "$NATIVE_INTRINSIC_BOOST_JSON" \
   --argjson native_raw_top_gap_requirements "$NATIVE_RAW_TOP_GAP_REQUIREMENTS_JSON" \
+  --argjson native_raw_signal_targeted_variants "$NATIVE_RAW_SIGNAL_TARGETED_VARIANTS_JSON" \
   --argjson native_raw_candidate_search "$NATIVE_RAW_CANDIDATE_SEARCH_JSON" \
   --argjson native_raw_adaptive_retry "$NATIVE_RAW_ADAPTIVE_RETRY_JSON" \
   --argjson native_raw_hardening "$NATIVE_RAW_HARDENING_JSON" \
@@ -965,6 +988,7 @@ SUMMARY_JSON="$(jq -nc \
     native_profile_autofill: $native_profile_autofill,
     native_intrinsic_boost: $native_intrinsic_boost,
     native_raw_top_gap_requirements: $native_raw_top_gap_requirements,
+    native_raw_signal_targeted_variants: $native_raw_signal_targeted_variants,
     native_raw_candidate_search: $native_raw_candidate_search,
     native_raw_adaptive_retry: $native_raw_adaptive_retry,
     native_raw_hardening: $native_raw_hardening,

tools/mcp/synthesize_raw_signal_targeted_variants.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+import argparse
+import json
+from pathlib import Path
+from typing import Dict, List
+
+
+def load_json(path: Path):
+    with path.open("r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def write_json(path: Path, obj) -> None:
+    with path.open("w", encoding="utf-8") as f:
+        json.dump(obj, f, indent=2, sort_keys=True)
+        f.write("\n")
+
+
+def req_from_signal(signal: str, idx: int) -> Dict:
+    if signal.startswith("missing_prerequisite_op:"):
+        op = signal.split(":", 1)[1]
+        txt = f"raw signal-targeted policy: include prerequisite operation `{op}` in concrete tasks where applicable."
+    elif signal.startswith("missing_execution_contract:"):
+        field = signal.split(":", 1)[1]
+        txt = f"raw signal-targeted policy: set executionContract.{field}=true for generated tasks requiring safe deterministic execution."
+    elif signal.startswith("missing_reason_keyword:"):
+        key = signal.split(":", 1)[1]
+        txt = f"raw signal-targeted policy: reasons must explicitly include `{key}` risk/contract intent."
+    elif signal.startswith("native_task_count<"):
+        min_count = signal.split("<", 1)[1]
+        txt = f"raw signal-targeted policy: produce at least {min_count} concrete non-generic taskitems."
+    else:
+        txt = f"raw signal-targeted policy: address missing signal `{signal}` with concrete task structure."
+    return {
+        "requirementId": f"raw-signal-{idx+1}",
+        "kind": "constraint",
+        "normalizedText": txt,
+        "anchor": "raw_signal_targeted_variant",
+        "sourceLine": 0,
+        "ambiguous": False,
+    }
+
+
+def build_variants(prioritized_missing: List[Dict], max_variants: int) -> List[List[Dict]]:
+    if max_variants <= 0:
+        return []
+    reqs = [req_from_signal(str(row.get("missing", "")), i) for i, row in enumerate(prioritized_missing) if str(row.get("missing", ""))]
+    if not reqs:
+        return []
+
+    variants: List[List[Dict]] = []
+    # Single-signal focused variants.
+    for r in reqs:
+        variants.append([r])
+    # Pair bundles for cross-signal coupling.
+    for i in range(0, len(reqs), 2):
+        variants.append(reqs[i:i + 2])
+    # One all-signals compact bundle.
+    variants.append(reqs[: min(6, len(reqs))])
+
+    out: List[List[Dict]] = []
+    seen = set()
+    for v in variants:
+        key = tuple(x.get("requirementId", "") for x in v)
+        if not key or key in seen:
+            continue
+        seen.add(key)
+        out.append(v)
+        if len(out) >= max_variants:
+            break
+    return out
+
+
+def main() -> int:
+    p = argparse.ArgumentParser(description="Synthesize raw candidate variants targeted to top missing backlog signals.")
+    p.add_argument("--top-gaps", required=True)
+    p.add_argument("--max-variants", type=int, default=6)
+    p.add_argument("--out", required=True)
+    args = p.parse_args()
+
+    backlog = load_json(Path(args.top_gaps))
+    prioritized = list(backlog.get("prioritized_missing") or [])
+    variants = build_variants(prioritized, args.max_variants)
+
+    payload = {
+        "status": "ok",
+        "input_signal_count": len(prioritized),
+        "variant_count": len(variants),
+        "variants": variants,
+    }
+    write_json(Path(args.out), payload)
+    print(json.dumps({"status": "ok", "input_signal_count": len(prioritized), "variant_count": len(variants), "out": args.out}, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())