@miller-tech/uap 1.0.0

package/tools/agents/plugins/uap-enforce.ts

@@ -0,0 +1,314 @@
+import type { Plugin } from '@opencode-ai/plugin';
+
+/**
+ * Layer 2: UAP Enforcement Plugin for OpenCode (v1.0.0)
+ *
+ * ARCHITECTURE: PREPEND-NOT-REPLACE
+ * The loop breaker PREPENDS warning messages to commands but NEVER replaces them.
+ * This ensures the agent's actual work always executes, even during loop detection.
+ * The agent sees the warning in the output and can adjust its approach.
+ *
+ * 1. Loop Detection (ALL tool types):
+ *    - Tracks tool calls by full-content fingerprint
+ *    - bash: prepends warning echo, then runs the actual command
+ *    - write/edit: lets the write through but prepends warning to next bash call
+ *    - read: lets the read through but prepends warning to next bash call
+ *    - Escape hatch: after 3 consecutive warnings, resets fingerprint history
+ *
+ * 2. Hard Tool-Call Budget:
+ *    - After 30 tool calls, prepends "WRAP UP NOW" warning
+ *    - Proxy (Layer 1) handles actual termination at 50 calls
+ *
+ * 3. Telemetry:
+ *    - Logs all tool calls to /tmp/uap-telemetry.jsonl
+ */
+export const UapEnforce: Plugin = async ({ $ }) => {
+  const recentFingerprints: string[] = [];
+  const recentOutputHashes: string[] = [];
+  const MAX_HISTORY = 20;
+  const LOOP_THRESHOLD = 3;
+
+  // Escape hatch: track consecutive loop warnings
+  let consecutiveLoopWarnings = 0;
+  const ESCAPE_HATCH_THRESHOLD = 3;
+
+  // Pending warning: queued from write/read loops, prepended to next bash call
+  let pendingWarning: string | null = null;
+
+  // Track write content hashes
+  const recentWriteHashes: string[] = [];
+
+  let totalToolCalls = 0;
+  const SOFT_BUDGET = 30;
+
+  const TELEMETRY_PATH = '/tmp/uap-telemetry.jsonl';
+
+  const simpleHash = (s: string): string => {
+    let h = 0;
+    for (let i = 0; i < Math.min(s.length, 2000); i++) {
+      h = ((h << 5) - h + s.charCodeAt(i)) | 0;
+    }
+    return String(h);
+  };
+
+  // Write initial telemetry entry
+  await $`echo '{"event":"plugin_loaded","version":"1.0.0","ts":"'$(date -Iseconds)'"}' >> ${TELEMETRY_PATH}`
+    .quiet()
+    .nothrow();
+
+  return {
+    'tool.execute.before': async (input, output) => {
+      totalToolCalls++;
+
+      // --- Worktree enforcement (Layer 4) ---
+      // Warn when file writes happen outside a worktree
+      if ((input.tool === 'write' || input.tool === 'edit') && output.args?.filePath) {
+        const filePath = String(output.args.filePath);
+        const isInWorktree = filePath.includes('.worktrees/') || filePath.includes('/.worktrees/');
+        if (!isInWorktree) {
+          try {
+            // Check if worktrees are enabled and other agents are active
+            const result = await $`bash -c '
+              COORD_DB="./agents/data/coordination/coordination.db"
+              if [ -f "$COORD_DB" ]; then
+                ACTIVE=$(sqlite3 "$COORD_DB" "SELECT COUNT(*) FROM agent_registry WHERE status='"'"'active'"'"';" 2>/dev/null || echo 0)
+                if [ "$ACTIVE" -gt 1 ]; then
+                  echo "MULTI_AGENT"
+                fi
+              fi
+            '`
+              .quiet()
+              .nothrow();
+
+            if (result.stdout?.toString().includes('MULTI_AGENT')) {
+              await $`echo ${JSON.stringify(
+                JSON.stringify({
+                  event: 'worktree_warning',
+                  tool: input.tool,
+                  file: filePath.slice(0, 200),
+                  reason: 'multi-agent file write outside worktree',
+                  ts: new Date().toISOString(),
+                })
+              )} >> ${TELEMETRY_PATH}`
+                .quiet()
+                .nothrow();
+
+              // Inject warning into bash tool if the next call is bash
+              // For write/edit, we log but don't block (worktree creation is the agent's responsibility)
+            }
+          } catch {
+            /* fail safely */
+          }
+        }
+      }
+
+      // --- PolicyGate enforcement (Layer 3) ---
+      // Check all UAP policies before allowing tool execution.
+      // Uses the uap-policy CLI for cross-runtime compatibility.
+      try {
+        const argsJson = JSON.stringify(output.args || {}).slice(0, 1000);
+        const result =
+          await $`node dist/bin/policy.js check --operation ${input.tool} --args ${argsJson} 2>/dev/null`
+            .quiet()
+            .nothrow();
+
+        if (result.exitCode !== 0) {
+          const policyOutput = result.stdout?.toString() || '';
+          // Policy blocked this operation
+          if (policyOutput.includes('BLOCKED') || policyOutput.includes('blocked')) {
+            await $`echo ${JSON.stringify(
+              JSON.stringify({
+                event: 'policy_blocked',
+                tool: input.tool,
+                reason: policyOutput.slice(0, 200),
+                ts: new Date().toISOString(),
+              })
+            )} >> ${TELEMETRY_PATH}`
+              .quiet()
+              .nothrow();
+
+            if (input.tool === 'bash') {
+              output.args.command = [
+                `echo "[UAP-POLICY] BLOCKED: Operation '${input.tool}' violated a REQUIRED policy."`,
+                `echo "[UAP-POLICY] ${policyOutput.replace(/"/g, '\\"').slice(0, 200)}"`,
+                `echo "[UAP-POLICY] You must comply with the policy before retrying."`,
+              ].join(' && ');
+              return;
+            }
+            // For non-bash tools, log but allow through (policy gate in MCP router
+            // will catch it if the tool goes through the MCP path)
+          }
+        }
+      } catch {
+        // Policy check failed (CLI not built, DB not initialized, etc.)
+        // Fail open: allow the tool call but log the failure
+        await $`echo '{"event":"policy_check_error","tool":"${input.tool}","ts":"'$(date -Iseconds)'"}' >> ${TELEMETRY_PATH}`
+          .quiet()
+          .nothrow();
+      }
+
+      // --- Budget enforcement ---
+      // NOTE: The proxy (Layer 1) handles the actual budget termination by
+      // stripping tools after HARD_BUDGET requests. The plugin just logs warnings.
+      // Do NOT replace commands here - that creates infinite loops when
+      // tool_choice="required" forces another call.
+      if (totalToolCalls === SOFT_BUDGET && input.tool === 'bash') {
+        const original = output.args?.command || '';
+        output.args.command = [
+          'echo "[UAP-ENFORCE] WARNING: 30 tool calls used. WRAP UP your solution NOW."',
+          original,
+        ].join(' && ');
+        return;
+      }
+
+      // --- Inject pending warning from write/read loop into this bash call ---
+      if (pendingWarning && input.tool === 'bash') {
+        const original = output.args?.command || '';
+        output.args.command = `echo "${pendingWarning}" && ${original}`;
+        pendingWarning = null;
+        // Don't return -- still check for loops on this call
+      }
+
+      // --- Fingerprint-based loop detection ---
+      const argsStr = JSON.stringify(output.args || {});
+      const fingerprint = `${input.tool}:${argsStr.length > 500 ? simpleHash(argsStr) : argsStr}`;
+
+      const matches = recentFingerprints.filter((f) => f === fingerprint);
+      if (matches.length >= LOOP_THRESHOLD) {
+        const loopCount = matches.length + 1;
+        consecutiveLoopWarnings++;
+
+        // --- ESCAPE HATCH: after N consecutive warnings, reset history ---
+        if (consecutiveLoopWarnings >= ESCAPE_HATCH_THRESHOLD) {
+          recentFingerprints.length = 0;
+          recentWriteHashes.length = 0;
+          consecutiveLoopWarnings = 0;
+          await $`echo '{"event":"escape_hatch","tool":"${input.tool}","count":${loopCount}}' >> ${TELEMETRY_PATH}`
+            .quiet()
+            .nothrow();
+          // Let this call through completely clean
+          return;
+        }
+
+        if (input.tool === 'bash') {
+          // PREPEND warning with SEARCH SUGGESTION, then run the ACTUAL command
+          const original = output.args?.command || '';
+          const warning = [
+            `echo "[UAP-ENFORCE] LOOP WARNING (${loopCount}x): Same command repeated."`,
+            `echo "[UAP-ENFORCE] Try a DIFFERENT approach. Hints:"`,
+            `echo "[UAP-ENFORCE]   - SEARCH ONLINE: uap_search 'your error message or question'"`,
+            `echo "[UAP-ENFORCE]   - If a dep is missing, install it (apt-get, pip, cpan)"`,
+            `echo "[UAP-ENFORCE]   - If output is wrong, read the test/verifier first"`,
+            `echo "[UAP-ENFORCE]   - Check /app/tmp/web_research.txt for pre-fetched hints"`,
+          ].join(' && ');
+          output.args.command = `${warning} && ${original}`;
+          await $`echo '{"event":"loop_warn_bash","count":${loopCount}}' >> ${TELEMETRY_PATH}`
+            .quiet()
+            .nothrow();
+        } else if (input.tool === 'write' || input.tool === 'edit') {
+          // LET THE WRITE THROUGH but queue a warning for the next bash call
+          pendingWarning = `[UAP-ENFORCE] WRITE LOOP (${loopCount}x): You wrote identical content. Try a DIFFERENT approach. Read the test/verifier to understand expected format.`;
+          await $`echo '{"event":"loop_warn_write","count":${loopCount}}' >> ${TELEMETRY_PATH}`
+            .quiet()
+            .nothrow();
+          // DO NOT modify output -- let the write execute
+        } else if (input.tool === 'read') {
+          // LET THE READ THROUGH but queue a warning
+          pendingWarning = `[UAP-ENFORCE] READ LOOP (${loopCount}x): You read the same file ${loopCount} times. Move on to the next step.`;
+          await $`echo '{"event":"loop_warn_read","count":${loopCount}}' >> ${TELEMETRY_PATH}`
+            .quiet()
+            .nothrow();
+          // DO NOT modify output -- let the read execute
+        }
+      } else {
+        // Not a loop -- reset consecutive warning counter
+        consecutiveLoopWarnings = 0;
+      }
+
+      // --- Content-aware write dedup ---
+      if (input.tool === 'write' && output.args?.content) {
+        const contentHash = simpleHash(output.args.content);
+        const contentMatches = recentWriteHashes.filter((h) => h === contentHash);
+        if (contentMatches.length >= 3) {
+          // Queue warning but LET THE WRITE THROUGH
+          pendingWarning = `[UAP-ENFORCE] CONTENT DEDUP: Identical content written ${contentMatches.length + 1} times. Your approach is not working. Try something FUNDAMENTALLY different.`;
+          await $`echo '{"event":"content_dedup","count":${contentMatches.length + 1}}' >> ${TELEMETRY_PATH}`
+            .quiet()
+            .nothrow();
+        }
+        recentWriteHashes.push(contentHash);
+        if (recentWriteHashes.length > MAX_HISTORY) {
+          recentWriteHashes.shift();
+        }
+      }
+
+      // Track fingerprint
+      recentFingerprints.push(fingerprint);
+      if (recentFingerprints.length > MAX_HISTORY) {
+        recentFingerprints.shift();
+      }
+    },
+
+    // --- Policy-aware tool descriptions (Layer 3) ---
+    // Inject active REQUIRED policy constraints into tool descriptions
+    // so the LLM is aware of rules before making tool calls.
+    'tool.definition': async (_input, output) => {
+      try {
+        const result = await $`node dist/bin/policy.js list --category code 2>/dev/null`
+          .quiet()
+          .nothrow();
+
+        if (result.exitCode === 0 && result.stdout) {
+          const policyText = result.stdout.toString().trim();
+          if (policyText && policyText.includes('REQUIRED')) {
+            const suffix =
+              '\n\n[UAP Policy Constraints: ' +
+              policyText
+                .split('\n')
+                .filter((l: string) => l.includes('REQUIRED'))
+                .map((l: string) => l.trim())
+                .join('; ')
+                .slice(0, 300) +
+              ']';
+            if (output.description) {
+              output.description = output.description + suffix;
+            }
+          }
+        }
+      } catch {
+        // Fail silently - policy injection is best-effort
+      }
+    },
+
+    'tool.execute.after': async (input, _output) => {
+      const outputStr = typeof _output?.output === 'string' ? _output.output : '';
+
+      // Output-based loop detection
+      if (outputStr.length > 0) {
+        const hash = simpleHash(outputStr);
+        recentOutputHashes.push(hash);
+        if (recentOutputHashes.length > MAX_HISTORY) {
+          recentOutputHashes.shift();
+        }
+      }
+
+      // Telemetry
+      const entry = {
+        event: 'tool_call',
+        tool: input.tool,
+        n: totalToolCalls,
+        ts: new Date().toISOString(),
+        args_preview:
+          typeof input.args?.command === 'string'
+            ? input.args.command.slice(0, 200)
+            : typeof input.args?.filePath === 'string'
+              ? input.args.filePath
+              : typeof input.args?.url === 'string'
+                ? input.args.url.slice(0, 200)
+                : '...',
+      };
+
+      await $`echo ${JSON.stringify(JSON.stringify(entry))} >> ${TELEMETRY_PATH}`.quiet().nothrow();
+    },
+  };
+};

package/tools/agents/scripts/chat_template_verifier.py

@@ -0,0 +1,343 @@
+#!/usr/bin/env python3
+"""
+UAP Chat Template Verifier
+
+Model-agnostic chat template auto-finder and verifier.
+Validates Jinja2 syntax, renders test data, and checks for
+tool call format support.
+
+Works with any chat template format:
+  - ChatML (<|im_start|>/<|im_end|>)
+  - Llama (<|begin_of_text|>/<|end_of_text|>)
+  - Mistral ([INST]/[/INST])
+  - Custom formats
+
+Usage:
+    python3 chat_template_verifier.py [template_path]
+
+Auto-detection looks for templates in standard locations relative to project root.
+"""
+
+import sys
+import os
+import re
+from pathlib import Path
+from datetime import datetime
+
+
+def find_project_root():
+    """Find the UAP project root directory."""
+    current = Path(__file__).resolve().parent
+
+    # Walk up from script location until we find package.json or .git
+    for parent in [current] + list(current.parents):
+        if (parent / "package.json").exists() or (parent / ".git" / "config").exists():
+            return parent
+
+    return current
+
+
+def find_chat_templates(project_root=None):
+    """Find all chat template files in project."""
+    if not project_root:
+        project_root = find_project_root()
+
+    templates = []
+
+    # Standard locations to check (in priority order)
+    search_paths = [
+        project_root / "tools" / "agents" / "config",
+        project_root / "config" / "model-profiles",
+        project_root,
+    ]
+
+    for search_path in search_paths:
+        if not search_path.exists():
+            continue
+
+        for pattern in ["chat_template.jinja", "*.jinja", "*.jinja2"]:
+            for found in search_path.glob(pattern):
+                # Skip backup files
+                if ".backup." in found.name:
+                    continue
+                templates.append(found)
+
+    # Deduplicate and sort by path length (prefer deeper/more specific paths)
+    seen = set()
+    unique = []
+    for t in templates:
+        resolved = t.resolve()
+        if resolved not in seen:
+            seen.add(resolved)
+            unique.append(t)
+
+    # Sort: prefer tools/agents/config/ over root
+    return sorted(unique, key=lambda x: (0 if "tools" in str(x) else 1, len(str(x))))
+
+
+def validate_template_syntax(content):
+    """Validate Jinja2 template syntax with correct regex patterns."""
+    issues = []
+
+    # Count balanced blocks using correct Jinja2 syntax
+    block_pairs = [
+        ("if", r"\{%-?\s*if\s+", r"\{%-?\s*endif\s*-?%\}"),
+        ("for", r"\{%-?\s*for\s+", r"\{%-?\s*endfor\s*-?%\}"),
+        ("macro", r"\{%-?\s*macro\s+", r"\{%-?\s*endmacro\s*-?%\}"),
+    ]
+
+    for tag_name, open_pattern, close_pattern in block_pairs:
+        opens = len(re.findall(open_pattern, content))
+        closes = len(re.findall(close_pattern, content))
+
+        if opens != closes:
+            issues.append(
+                f"Unbalanced {tag_name} blocks: {opens} open vs {closes} close"
+            )
+
+    # Check for broken tag syntax
+    broken_tags = re.findall(r"\{-?%[^}]*%\}", content)
+    for tag in broken_tags:
+        if tag.startswith("{-%") and not tag.startswith("{%-"):
+            issues.append(f"Invalid tag syntax: {tag[:40]}...")
+
+    # Check for double-opened tags like {%- {%- elif %}
+    double_opens = re.findall(r"\{%-?\s*\{%-?", content)
+    if double_opens:
+        issues.append(f"Found {len(double_opens)} double-opened tags")
+
+    # Check for stray endmacro without macro
+    macros = len(re.findall(r"\{%-?\s*macro\s+", content))
+    endmacros = len(re.findall(r"\{%-?\s*endmacro\s*-?%\}", content))
+    if endmacros > macros:
+        issues.append(f"Found {endmacros - macros} stray endmacro tag(s)")
+
+    return issues
+
+
+def verify_template_with_jinja(template_content):
+    """Verify template can be parsed by Jinja2."""
+    try:
+        from jinja2 import Environment, BaseLoader
+        import json
+
+        env = Environment(loader=BaseLoader())
+
+        # Try to compile the template
+        template = env.from_string(template_content)
+
+        # Test with minimal valid input
+        test_data = {
+            "messages": [
+                {"role": "system", "content": "Test system message"},
+                {"role": "user", "content": "Hello"},
+            ],
+            "add_generation_prompt": True,
+            "enable_thinking": False,
+        }
+
+        try:
+            result = template.render(**test_data)
+            print(f"  [OK] Template compiled and rendered ({len(result)} chars)")
+
+            # Test tool call round-trip
+            test_tool_data = {
+                "messages": [
+                    {"role": "user", "content": "Read file"},
+                    {
+                        "role": "assistant",
+                        "content": "",
+                        "tool_calls": [
+                            {
+                                "function": {
+                                    "name": "read_file",
+                                    "arguments": json.dumps({"path": "/etc/hosts"}),
+                                }
+                            }
+                        ],
+                    },
+                    {
+                        "role": "tool",
+                        "name": "read_file",
+                        "content": "127.0.0.1 localhost",
+                    },
+                ],
+                "add_generation_prompt": True,
+                "enable_thinking": False,
+            }
+
+            result2 = template.render(**test_tool_data)
+
+            # Check for various tool call formats (model-agnostic)
+            tool_formats = [
+                ("<tool_call>", "ChatML/Qwen3 format"),
+                ("<function_call>", "legacy XML format"),
+                ("<function=", "function= style"),
+                ('"name"', "JSON tool call"),
+            ]
+
+            found_format = False
+            for marker, format_name in tool_formats:
+                if marker in result2:
+                    print(f"  [OK] Tool call format verified ({format_name})")
+                    found_format = True
+                    break
+
+            if not found_format:
+                print("  [WARN] Tool call tags not found in output")
+
+            return True
+
+        except Exception as e:
+            error_msg = str(e)
+            if "undefined" in error_msg.lower():
+                # Variable undefined is expected with minimal test data
+                print(f"  [OK] Template parsed (expected variable: {error_msg[:60]})")
+                return True
+            else:
+                print(f"  [FAIL] Render error: {error_msg[:100]}")
+                return False
+
+    except ImportError:
+        print("  [SKIP] Jinja2 not installed (pip install jinja2)")
+        return None
+    except Exception as e:
+        error_msg = str(e)
+        line_match = re.search(r"line (\d+)", error_msg)
+
+        if line_match:
+            line_num = int(line_match.group(1))
+            lines = template_content.split("\n")
+            print(f"\n  [FAIL] Error at line {line_num}:")
+            start = max(0, line_num - 3)
+            for i in range(start, min(line_num + 2, len(lines))):
+                marker = ">>>" if i == line_num - 1 else "   "
+                print(f"  {marker} {i + 1}: {lines[i][:80]}")
+        else:
+            print(f"\n  [FAIL] Template parsing error: {error_msg[:200]}")
+
+        return False
+
+
+def main():
+    """Main execution with auto-detection."""
+
+    print("=" * 70)
+    print("UAP Chat Template Verifier")
+    print("=" * 70)
+
+    # Get project root
+    project_root = find_project_root()
+    print(f"\nProject root: {project_root}")
+
+    # Handle explicit path argument
+    if len(sys.argv) > 1:
+        target_template = Path(sys.argv[1])
+        if not target_template.exists():
+            print(f"Error: File not found: {target_template}")
+            sys.exit(1)
+    else:
+        # Find templates automatically
+        print("\nSearching for chat templates...")
+        templates = find_chat_templates(project_root)
+
+        if not templates:
+            print("Error: No chat template files found!")
+            print(
+                f"\nExpected at: {project_root / 'tools' / 'agents' / 'config' / 'chat_template.jinja'}"
+            )
+            sys.exit(1)
+
+        target_template = templates[0]
+
+        # Show all found templates
+        if len(templates) > 1:
+            print(f"  Found {len(templates)} template(s):")
+            for t in templates:
+                try:
+                    rel = t.relative_to(project_root)
+                except ValueError:
+                    rel = t
+                marker = " <-- using" if t == target_template else ""
+                print(f"    - {rel}{marker}")
+
+    try:
+        rel_path = target_template.relative_to(project_root)
+    except ValueError:
+        rel_path = target_template
+
+    print(f"Using: {rel_path}")
+
+    # Read content
+    try:
+        with open(target_template, "r", encoding="utf-8") as f:
+            content = f.read()
+        print(f"Loaded: {len(content)} bytes, {len(content.splitlines())} lines")
+    except Exception as e:
+        print(f"Error reading {target_template}: {e}")
+        sys.exit(1)
+
+    # Validate syntax
+    print("\nValidating template syntax...")
+    issues = validate_template_syntax(content)
+
+    if issues:
+        print(f"  Found {len(issues)} issue(s):")
+        for issue in issues:
+            print(f"    - {issue}")
+    else:
+        print("  [OK] No syntax issues detected")
+
+    # Verify with Jinja2
+    print("\nVerifying with Jinja2 parser...")
+    jinja_ok = verify_template_with_jinja(content)
+
+    if jinja_ok is True:
+        print("\n[OK] Template is valid and functional")
+    elif jinja_ok is False:
+        print("\n[FAIL] Template has errors - needs manual review")
+        sys.exit(1)
+    else:
+        print("\n[SKIP] Could not verify (install jinja2: pip install jinja2)")
+
+    # Show template features (model-agnostic detection)
+    print("\nTemplate features:")
+    features = [
+        ("System message handling", "role == 'system'" in content),
+        ("User message handling", "role == 'user'" in content),
+        ("Assistant message handling", "role == 'assistant'" in content),
+        ("Tool call support", "tool_calls" in content or "tool_call" in content),
+        ("Native tool descriptions", "for tool in tools" in content),
+        (
+            "Tool response support",
+            "role == 'tool'" in content or "tool_response" in content,
+        ),
+        (
+            "Thinking/reasoning mode",
+            "thinking" in content.lower() or "think" in content.lower(),
+        ),
+        ("ChatML format (<|im_start|>)", "<|im_start|>" in content),
+        ("Llama format (<|begin_of_text|>)", "<|begin_of_text|>" in content),
+        ("Mistral format ([INST])", "[INST]" in content),
+        ("Generation prompt", "add_generation_prompt" in content),
+    ]
+
+    for feature, has_it in features:
+        status = "[OK]" if has_it else "[--]"
+        print(f"  {status} {feature}")
+
+    print("\n" + "=" * 70)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        print("\nInterrupted")
+        sys.exit(130)
+    except Exception as e:
+        import traceback
+
+        print(f"\nUnexpected error: {e}")
+        traceback.print_exc()
+        sys.exit(1)

package/tools/agents/scripts/fix-qwen-template.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+/**
+ * Fix Qwen Chat Template - Node.js Wrapper
+ *
+ * Cross-platform shim that finds Python and delegates to the
+ * Python template fixer/verifier script in the same directory.
+ */
+
+import { execFileSync } from 'child_process';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { platform } from 'os';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+function getPythonExecutable() {
+  if (platform() === 'win32') {
+    return 'python';
+  }
+  try {
+    execFileSync('python3', ['--version'], { stdio: 'ignore' });
+    return 'python3';
+  } catch {
+    return 'python';
+  }
+}
+
+const pythonScript = join(__dirname, 'fix_qwen_chat_template.py');
+const args = process.argv.slice(2);
+
+try {
+  execFileSync(getPythonExecutable(), [pythonScript, ...args], {
+    stdio: 'inherit',
+    cwd: process.cwd(),
+  });
+} catch (error) {
+  process.exit(error.status || 1);
+}