forge-workflow 0.0.8 → 0.0.10

package/scripts/beads-context.sh

@@ -41,11 +41,124 @@ die() {
   exit 1
 }
 
+# Resolve a Windows bd.exe installation for bash-based helper flows.
+# This covers WSL/Git Bash cases where PowerShell can run bd.exe but bash PATH
+# does not include the Windows install directory.
+convert_windows_path() {
+  local raw="${1%$'\r'}"
+
+  if [[ -z "$raw" ]]; then
+    return 1
+  fi
+
+  if [[ ! "$raw" =~ ^[A-Za-z]:\\ ]]; then
+    printf '%s' "$raw"
+    return 0
+  fi
+
+  if command -v wslpath >/dev/null 2>&1; then
+    wslpath -u "$raw" 2>/dev/null && return 0
+  fi
+
+  if command -v cygpath >/dev/null 2>&1; then
+    cygpath -u "$raw" 2>/dev/null && return 0
+  fi
+
+  local drive rest
+  drive="$(printf '%s' "$raw" | cut -c1 | tr '[:upper:]' '[:lower:]')"
+  rest="${raw:2}"
+  rest="${rest//\\//}"
+  printf '/mnt/%s%s' "$drive" "$rest"
+}
+
+is_runnable_bd_candidate() {
+  local candidate="${1:-}"
+
+  if [[ -z "$candidate" || ! -f "$candidate" ]]; then
+    return 1
+  fi
+
+  [[ -x "$candidate" || "$candidate" == *.exe ]]
+}
+
+resolve_bd_cmd() {
+  local candidate=""
+  local converted=""
+
+  if [[ -n "${BD_CMD:-}" ]]; then
+    if [[ "${BD_CMD}" == *"/"* || "${BD_CMD}" == *"\\"* ]]; then
+      converted="$(convert_windows_path "$BD_CMD")"
+      if is_runnable_bd_candidate "$converted"; then
+        printf '%s' "$converted"
+        return 0
+      fi
+
+      is_runnable_bd_candidate "$BD_CMD" || return 1
+    fi
+    printf '%s' "$BD_CMD"
+    return 0
+  fi
+
+  if command -v bd >/dev/null 2>&1; then
+    printf '%s' "bd"
+    return 0
+  fi
+
+  if command -v bd.exe >/dev/null 2>&1; then
+    printf '%s' "bd.exe"
+    return 0
+  fi
+
+  for candidate in \
+    "$HOME/.local/bin/bd" \
+    "$HOME/.local/bin/bd.exe" \
+    "$HOME/.bun/bin/bd" \
+    "$HOME/.bun/bin/bd.exe"
+  do
+    if is_runnable_bd_candidate "$candidate"; then
+      printf '%s' "$candidate"
+      return 0
+    fi
+  done
+
+  if command -v where.exe >/dev/null 2>&1; then
+    while IFS= read -r candidate; do
+      candidate="${candidate%$'\r'}"
+      [[ -z "$candidate" ]] && continue
+
+      converted="$(convert_windows_path "$candidate")"
+      if is_runnable_bd_candidate "$converted"; then
+        printf '%s' "$converted"
+        return 0
+      fi
+
+      if is_runnable_bd_candidate "$candidate"; then
+        printf '%s' "$candidate"
+        return 0
+      fi
+    done < <(where.exe bd 2>/dev/null || true)
+  fi
+
+  return 1
+}
+
+BD=""
+
+get_bd_cmd() {
+  if [[ -z "$BD" ]]; then
+    BD="$(resolve_bd_cmd)" || die "bd is required but not found"
+  fi
+
+  printf '%s' "$BD"
+}
+
 # Run bd update and check for errors in both exit code and output.
 # bd update exits 0 even for non-existent issues, so we check stdout too.
 bd_update() {
+  local bd_cmd
+  bd_cmd="$(get_bd_cmd)"
   local output
-  output="$(bd update "$@" 2>&1)"
+  output="$("$bd_cmd" update "$@" 2>&1)"
   local rc=$?
 
   if [[ $rc -ne 0 ]]; then
@@ -66,8 +179,10 @@ bd_update() {
 
 # Run bd comments add and check for errors similarly.
 bd_comment() {
+  local bd_cmd
+  bd_cmd="$(get_bd_cmd)"
   local output
-  output="$(bd comments add "$@" 2>&1)"
+  output="$("$bd_cmd" comments add "$@" 2>&1)"
   local rc=$?
 
   if [[ $rc -ne 0 ]]; then
@@ -172,10 +287,12 @@ cmd_parse_progress() {
   fi
 
   local issue_id="$1"
+  local bd_cmd
+  bd_cmd="$(get_bd_cmd)"
 
   # Get the issue JSON — detect non-existent issues
   local json
-  json="$(bd show "$issue_id" --json 2>&1)" || die "Failed to show issue ${issue_id}"
+  json="$("$bd_cmd" show "$issue_id" --json 2>&1)" || die "Failed to show issue ${issue_id}"
 
   # bd show may exit 0 but print an error for non-existent issues
   # Match specific bd error patterns, not the word "error" in data fields
@@ -320,10 +437,12 @@ cmd_validate() {
 
   local issue_id="$1"
   local warnings=0
+  local bd_cmd
+  bd_cmd="$(get_bd_cmd)"
 
   # Get issue JSON
   local json
-  json="$(bd show "$issue_id" --json 2>&1)" || {
+  json="$("$bd_cmd" show "$issue_id" --json 2>&1)" || {
     echo "Error: Failed to retrieve issue ${issue_id}" >&2
     exit 1
   }
@@ -357,7 +476,7 @@ cmd_validate() {
 
   # Get comments to check for stage transitions
   local comments
-  comments="$(bd comments list "$issue_id" 2>/dev/null || true)"
+  comments="$("$bd_cmd" comments "$issue_id" 2>/dev/null || true)"
 
   # Check 2: At least one stage transition exists
   local has_transition=false

package/scripts/beads-context.test.js

@@ -22,16 +22,24 @@ function isBdAvailable() {
 	}
 }
 
+function shouldRunBeadsIntegration() {
+	return process.env.RUN_BEADS_INTEGRATION === '1' && isBdAvailable();
+}
+
 /**
  * Helper: run the beads-context.sh script with given args.
  * Returns { exitCode, stdout, stderr }.
  */
 async function run(...args) {
+	return runWithEnv(args);
+}
+
+async function runWithEnv(args, envOverrides = {}) {
 	const proc = Bun.spawn([resolveBashCommand(), SCRIPT_PATH, ...args], {
 		cwd: WORKTREE_ROOT,
 		stdout: 'pipe',
 		stderr: 'pipe',
-		env: { ...process.env },
+		env: { ...process.env, ...envOverrides },
 	});
 	const stdout = await new Response(proc.stdout).text();
 	const stderr = await new Response(proc.stderr).text();
@@ -55,7 +63,16 @@ async function bd(...args) {
 	return { exitCode, stdout, stderr };
 }
 
-describe.skipIf(!isBdAvailable())('scripts/beads-context.sh', () => {
+describe('scripts/beads-context.sh command resolution', () => {
+	test('script includes Windows-aware bd resolution fallback', () => {
+		const content = fs.readFileSync(SCRIPT_PATH, 'utf8');
+		expect(content).toContain('resolve_bd_cmd');
+		expect(content).toContain('where.exe');
+		expect(content).toContain('$HOME/.local/bin/bd.exe');
+	});
+});
+
+describe.skipIf(!shouldRunBeadsIntegration())('scripts/beads-context.sh', () => {
 	let testIssueId;
 
 	// Create a temporary test issue for isolation
@@ -470,7 +487,7 @@ describe('/dev command integration with beads-context.sh', () => {
 	});
 });
 
-describe('/status command integration with smart-status.sh', () => {
+describe('/status command integration with smart-status', () => {
 	const STATUS_MD_PATH = path.join(
 		__dirname,
 		'..',
@@ -485,7 +502,7 @@ describe('/status command integration with smart-status.sh', () => {
 	});
 
 	test('status.md should reference smart-status.sh as the primary status command', () => {
-		expect(statusContent).toContain('smart-status.sh');
+		expect(statusContent).toContain('bash scripts/smart-status.sh');
 	});
 
 	test('status.md should include hint to use bd show for full context', () => {

package/scripts/beads-migrate-to-dolt.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+NODE_CMD="${NODE_CMD:-node}"
+
+exec "$NODE_CMD" "$SCRIPT_DIR/lib/beads-migrate-to-dolt.mjs" "$@"

package/scripts/beads-upgrade-smoke.sh

@@ -0,0 +1,263 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+BD_CMD="${BD_CMD:-bd}"
+NODE_CMD="${NODE_CMD:-node}"
+PROJECT_ROOT="${PROJECT_ROOT:-$(pwd)}"
+ARTIFACT_DIR="${BEADS_UPGRADE_SMOKE_ARTIFACT_DIR:-${PROJECT_ROOT}/.artifacts/beads-upgrade-smoke}"
+COMMAND_LOG_PATH="${ARTIFACT_DIR}/commands.jsonl"
+SUMMARY_PATH="${ARTIFACT_DIR}/summary.json"
+CLEANUP_REASON="Beads upgrade smoke cleanup"
+SMOKE_RUN_ID="${BEADS_UPGRADE_SMOKE_RUN_ID:-$(date +%s)-$$}"
+PRIMARY_ISSUE_TITLE="Beads upgrade smoke primary (${SMOKE_RUN_ID})"
+DEPENDENT_ISSUE_TITLE="Beads upgrade smoke dependent (${SMOKE_RUN_ID})"
+
+mkdir -p "${ARTIFACT_DIR}"
+: > "${COMMAND_LOG_PATH}"
+
+created_issue_ids=()
+closed_issue_ids=()
+failed_step=""
+failure_message=""
+
+parse_issue_id() {
+  local output="$1"
+  if [[ "${output}" =~ Created[[:space:]]+issue:[[:space:]]*([[:alnum:]-]+) ]]; then
+    printf '%s' "${BASH_REMATCH[1]}"
+    return 0
+  fi
+  if [[ "${output}" =~ \"id\"[[:space:]]*:[[:space:]]*\"([[:alnum:]-]+)\" ]]; then
+    printf '%s' "${BASH_REMATCH[1]}"
+    return 0
+  fi
+  return 1
+}
+
+find_issue_id_by_title() {
+  local issue_title="$1"
+  local list_output
+  list_output="$("${BD_CMD}" list --json --limit=50 2>/dev/null)" || return 1
+
+  "${NODE_CMD}" -e '
+    const fs = require("node:fs");
+    const [issueTitle] = process.argv.slice(1);
+    try {
+      const rows = JSON.parse(fs.readFileSync(0, "utf8"));
+      if (!Array.isArray(rows)) {
+        process.exit(1);
+      }
+      const match = rows.find((row) => row && row.title === issueTitle && typeof row.id === "string");
+      if (!match) {
+        process.exit(1);
+      }
+      process.stdout.write(match.id);
+    } catch {
+      process.exit(1);
+    }
+  ' "${issue_title}" <<< "${list_output}"
+}
+
+append_command() {
+  local step="$1"
+  local command_name="$2"
+  local command_text="$3"
+  local exit_code="$4"
+  local stdout_path="$5"
+  local stderr_path="$6"
+
+  "${NODE_CMD}" -e '
+    const fs = require("node:fs");
+    const [logPath, step, commandName, commandText, exitCode, stdoutPath, stderrPath] = process.argv.slice(1);
+    const entry = {
+      step,
+      commandName,
+      commandText,
+      exitCode: Number(exitCode),
+      stdoutPath,
+      stderrPath,
+    };
+    fs.appendFileSync(logPath, JSON.stringify(entry) + "\n");
+  ' "${COMMAND_LOG_PATH}" "${step}" "${command_name}" "${command_text}" "${exit_code}" "${stdout_path}" "${stderr_path}"
+}
+
+read_output_snippet() {
+  local file_path="$1"
+  if [[ ! -f "${file_path}" ]]; then
+    return 0
+  fi
+
+  "${NODE_CMD}" -e '
+    const fs = require("node:fs");
+    const [filePath] = process.argv.slice(1);
+    const text = fs.readFileSync(filePath, "utf8");
+    process.stdout.write(text.slice(0, 4096));
+  ' "${file_path}"
+}
+
+write_summary() {
+  local ok="$1"
+
+  "${NODE_CMD}" -e '
+    const fs = require("node:fs");
+    const [
+      commandLogPath,
+      summaryPath,
+      okValue,
+      failedStep,
+      failureMessage,
+      artifactDir,
+      createdJson,
+      closedJson,
+    ] = process.argv.slice(1);
+    const commands = fs.readFileSync(commandLogPath, "utf8")
+      .split(/\r?\n/)
+      .filter(Boolean)
+      .map((line) => JSON.parse(line));
+    const summary = {
+      ok: okValue === "true",
+      failedStep: failedStep || null,
+      failureMessage: failureMessage || null,
+      commands,
+      cleanup: {
+        createdIssueIds: JSON.parse(createdJson),
+        closedIssueIds: JSON.parse(closedJson),
+      },
+      failureArtifact: summaryPath,
+      artifactDir,
+    };
+    fs.writeFileSync(summaryPath, JSON.stringify(summary, null, 2) + "\n");
+  ' "${COMMAND_LOG_PATH}" "${SUMMARY_PATH}" "${ok}" "${failed_step}" "${failure_message}" "${ARTIFACT_DIR}" "$(printf '%s\n' "${created_issue_ids[@]:-}" | "${NODE_CMD}" -e 'const fs=require("node:fs"); const lines=fs.readFileSync(0,"utf8").split(/\r?\n/).filter(Boolean); process.stdout.write(JSON.stringify(lines));')" "$(printf '%s\n' "${closed_issue_ids[@]:-}" | "${NODE_CMD}" -e 'const fs=require("node:fs"); const lines=fs.readFileSync(0,"utf8").split(/\r?\n/).filter(Boolean); process.stdout.write(JSON.stringify(lines));')"
+}
+
+run_bd_step() {
+  local step="$1"
+  local command_name="$2"
+  shift 2
+
+  local stdout_file stderr_file exit_code command_text
+  stdout_file="${ARTIFACT_DIR}/$(printf '%s' "${step}" | tr '[:upper:]' '[:lower:]').stdout"
+  stderr_file="${ARTIFACT_DIR}/$(printf '%s' "${step}" | tr '[:upper:]' '[:lower:]').stderr"
+  command_text="$*"
+
+  if "${BD_CMD}" "$@" >"${stdout_file}" 2>"${stderr_file}"; then
+    exit_code=0
+  else
+    exit_code=$?
+  fi
+
+  append_command "${step}" "${command_name}" "${command_text}" "${exit_code}" "${stdout_file}" "${stderr_file}"
+
+  if [[ "${exit_code}" -ne 0 ]]; then
+    failed_step="${command_name}"
+    local stderr_text stdout_text
+    stderr_text="$(read_output_snippet "${stderr_file}")"
+    stdout_text="$(read_output_snippet "${stdout_file}")"
+    failure_message="${stderr_text:-${stdout_text:-${command_text}}}"
+    return "${exit_code}"
+  fi
+
+  cat "${stdout_file}"
+}
+
+is_closed_issue() {
+  local issue_id="$1"
+  local existing
+  for existing in "${closed_issue_ids[@]:-}"; do
+    if [[ "${existing}" == "${issue_id}" ]]; then
+      return 0
+    fi
+  done
+  return 1
+}
+
+rollback_unclosed_issues() {
+  local idx issue_id
+  for (( idx=${#created_issue_ids[@]} - 1; idx>=0; idx-- )); do
+    issue_id="${created_issue_ids[idx]}"
+    if is_closed_issue "${issue_id}"; then
+      continue
+    fi
+    if run_bd_step "rollback-close-${issue_id}" "close" close "${issue_id}" "--reason=${CLEANUP_REASON}" >/dev/null; then
+      closed_issue_ids+=("${issue_id}")
+    fi
+  done
+}
+
+handle_issue_id_parse_failure() {
+  local issue_title="$1"
+  local message="$2"
+  local recovered_issue_id=""
+
+  failed_step="create"
+  failure_message="${message}"
+
+  recovered_issue_id="$(find_issue_id_by_title "${issue_title}" || true)"
+  if [[ -n "${recovered_issue_id}" ]]; then
+    created_issue_ids+=("${recovered_issue_id}")
+  fi
+
+  rollback_unclosed_issues
+  write_summary "false"
+  exit 1
+}
+
+primary_output="$(run_bd_step "create-primary" "create" create --title="${PRIMARY_ISSUE_TITLE}" --type=task --priority=4)" || {
+  rollback_unclosed_issues
+  write_summary "false"
+  exit 1
+}
+primary_issue_id="$(parse_issue_id "${primary_output}")" || {
+  handle_issue_id_parse_failure "${PRIMARY_ISSUE_TITLE}" "Could not parse primary smoke issue ID"
+}
+created_issue_ids+=("${primary_issue_id}")
+
+dependent_output="$(run_bd_step "create-dependent" "create" create --title="${DEPENDENT_ISSUE_TITLE}" --type=task --priority=4)" || {
+  rollback_unclosed_issues
+  write_summary "false"
+  exit 1
+}
+dependent_issue_id="$(parse_issue_id "${dependent_output}")" || {
+  handle_issue_id_parse_failure "${DEPENDENT_ISSUE_TITLE}" "Could not parse dependent smoke issue ID"
+}
+created_issue_ids+=("${dependent_issue_id}")
+
+run_bd_step "list" "list" list --json --limit=50 >/dev/null || {
+  rollback_unclosed_issues
+  write_summary "false"
+  exit 1
+}
+
+run_bd_step "show-primary" "show" show "${primary_issue_id}" --json >/dev/null || {
+  rollback_unclosed_issues
+  write_summary "false"
+  exit 1
+}
+
+run_bd_step "dep-add" "dep" dep add "${primary_issue_id}" "${dependent_issue_id}" >/dev/null || {
+  rollback_unclosed_issues
+  write_summary "false"
+  exit 1
+}
+
+run_bd_step "close-dependent" "close" close "${dependent_issue_id}" "--reason=${CLEANUP_REASON}" >/dev/null || {
+  rollback_unclosed_issues
+  write_summary "false"
+  exit 1
+}
+closed_issue_ids+=("${dependent_issue_id}")
+
+run_bd_step "close-primary" "close" close "${primary_issue_id}" "--reason=${CLEANUP_REASON}" >/dev/null || {
+  rollback_unclosed_issues
+  write_summary "false"
+  exit 1
+}
+closed_issue_ids+=("${primary_issue_id}")
+
+run_bd_step "sync" "sync" sync >/dev/null || {
+  rollback_unclosed_issues
+  write_summary "false"
+  exit 1
+}
+
+write_summary "true"
+printf '%s\n' "${SUMMARY_PATH}"

package/scripts/behavioral-judge.sh

@@ -66,10 +66,25 @@ else
   INPUT="$(cat)"
 fi
 
-# Extract plan_output text if input is JSON, otherwise use raw input
-PLAN_TEXT="$INPUT"
-if command -v python3 >/dev/null 2>&1; then
-  EXTRACTED=$(echo "$INPUT" | python3 -c "
+extract_plan_text() {
+  if command -v node >/dev/null 2>&1; then
+    node -e "
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('end', () => {
+  try {
+    const parsed = JSON.parse(input);
+    const value = parsed && parsed.plan_output;
+    if (value) process.stdout.write(String(value));
+  } catch (_) {}
+});
+" 2>/dev/null
+    return $?
+  fi
+
+  if command -v python3 >/dev/null 2>&1; then
+    python3 -c "
 import sys, json
 try:
     d = json.load(sys.stdin)
@@ -78,10 +93,16 @@ try:
         print(val)
 except:
     pass
-" 2>/dev/null) || true
-  if [ -n "$EXTRACTED" ]; then
-    PLAN_TEXT="$EXTRACTED"
+" 2>/dev/null
+    return $?
   fi
+}
+
+# Extract plan_output text if input is JSON, otherwise use raw input
+PLAN_TEXT="$INPUT"
+EXTRACTED=$(printf '%s' "$INPUT" | extract_plan_text) || true
+if [ -n "$EXTRACTED" ]; then
+  PLAN_TEXT="$EXTRACTED"
 fi
 
 # ─── Judge prompt ────────────────────────────────────────────────────────────
@@ -158,7 +179,22 @@ parse_scores() {
   local response="$1"
   # Extract the JSON object from the LLM response content
   local content
-  content=$(echo "$response" | python3 -c "
+  if command -v node >/dev/null 2>&1; then
+    content=$(printf '%s' "$response" | node -e "
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('end', () => {
+  try {
+    const data = JSON.parse(input);
+    const choice = (data.choices || [])[0] || {};
+    const message = choice.message || {};
+    process.stdout.write(String(message.content || ''));
+  } catch (_) {}
+});
+" 2>/dev/null) || true
+  elif command -v python3 >/dev/null 2>&1; then
+    content=$(printf '%s' "$response" | python3 -c "
 import sys, json
 try:
     data = json.load(sys.stdin)
@@ -170,6 +206,9 @@ try:
 except Exception as e:
     pass
 " 2>/dev/null) || true
+  else
+    content=""
+  fi
 
   if [ -z "$content" ]; then
     echo ""
@@ -178,7 +217,37 @@ except Exception as e:
 
   # Parse scores from content JSON
   local scores
-  scores=$(echo "$content" | python3 -c "
+  if command -v node >/dev/null 2>&1; then
+    scores=$(printf '%s' "$content" | node -e "
+let text = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => { text += chunk; });
+process.stdin.on('end', () => {
+  function emit(value) {
+    const security = Number.parseInt(value.security, 10);
+    const tdd = Number.parseInt(value.tdd, 10);
+    const design = Number.parseInt(value.design, 10);
+    const structural = Number.parseInt(value.structural, 10);
+    if ([security, tdd, design, structural].every(score => Number.isInteger(score) && score >= 0 && score <= 5)) {
+      console.log([security, tdd, design, structural].join(' '));
+      return true;
+    }
+    return false;
+  }
+  try {
+    if (emit(JSON.parse(text.trim()))) return;
+  } catch (_) {}
+  const match = text.match(/\{[^}]+\}/s);
+  if (match) {
+    try {
+      if (emit(JSON.parse(match[0]))) return;
+    } catch (_) {}
+  }
+  process.exit(1);
+});
+" 2>/dev/null) || { echo ""; return 1; }
+  elif command -v python3 >/dev/null 2>&1; then
+    scores=$(printf '%s' "$content" | python3 -c "
 import sys, json, re
 text = sys.stdin.read().strip()
 # Try direct JSON parse first
@@ -209,6 +278,10 @@ if m:
         pass
 sys.exit(1)
 " 2>/dev/null) || { echo ""; return 1; }
+  else
+    echo ""
+    return 1
+  fi
 
   echo "$scores"
 }
@@ -221,10 +294,23 @@ call_openrouter() {
 
   # Escape prompt for JSON
   local escaped_prompt
-  escaped_prompt=$(echo "$prompt" | python3 -c "
+  if command -v node >/dev/null 2>&1; then
+    escaped_prompt=$(printf '%s' "$prompt" | node -e "
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('end', () => {
+  process.stdout.write(JSON.stringify(input));
+});
+" 2>/dev/null) || escaped_prompt='""'
+  elif command -v python3 >/dev/null 2>&1; then
+    escaped_prompt=$(printf '%s' "$prompt" | python3 -c "
 import sys, json
 print(json.dumps(sys.stdin.read()))
 " 2>/dev/null) || escaped_prompt='""'
+  else
+    escaped_prompt='""'
+  fi
 
   local body
   body=$(cat <<JSON
@@ -295,7 +381,22 @@ if [ "${BEHAVIORAL_JUDGE_TEST_MODE}" = "1" ]; then
   fi
 
   # Parse mock scores
-  scores=$(echo "$mock_scores" | python3 -c "
+  if command -v node >/dev/null 2>&1; then
+    scores=$(printf '%s' "$mock_scores" | node -e "
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('end', () => {
+  const scores = JSON.parse(input);
+  const security = Number.parseInt(scores.security ?? 3, 10);
+  const tdd = Number.parseInt(scores.tdd ?? 3, 10);
+  const design = Number.parseInt(scores.design ?? 3, 10);
+  const structural = Number.parseInt(scores.structural ?? 3, 10);
+  console.log([security, tdd, design, structural].join(' '));
+});
+" 2>/dev/null) || scores="3 3 3 3"
+  elif command -v python3 >/dev/null 2>&1; then
+    scores=$(printf '%s' "$mock_scores" | python3 -c "
 import sys, json
 d = json.loads(sys.stdin.read())
 s = int(d.get('security', 3))
@@ -304,6 +405,9 @@ de = int(d.get('design', 3))
 st = int(d.get('structural', 3))
 print(f'{s} {t} {de} {st}')
 " 2>/dev/null) || scores="3 3 3 3"
+  else
+    scores="3 3 3 3"
+  fi
 
   read -r sec tdd_s des str <<< "$scores"
   compute_result "$sec" "$tdd_s" "$des" "$str" "$judge_model" "$judge_calls"