aiblueprint-cli 1.4.99 → 1.4.101

package/agents-config/skills/apex/scripts/setup-templates.sh

@@ -1,154 +1,36 @@
 #!/bin/bash
-# APEX Template Setup Script
-# Creates output directory structure and initializes template files
-#
-# Usage: setup-templates.sh "feature-name" [other args...]
-# The script auto-generates the task ID with the next available number.
+# Compatibility initializer for older APEX callers.
 
-set -e
+set -euo pipefail
 
-# Arguments - first arg is now just the feature name (kebab-case)
-FEATURE_NAME="$1"
-TASK_DESCRIPTION="$2"
-AUTO_MODE="${3:-false}"
-EXAMINE_MODE="${4:-false}"
-SAVE_MODE="${5:-false}"
-TEST_MODE="${6:-false}"
-ECONOMY_MODE="${7:-false}"
-BRANCH_MODE="${8:-false}"
-PR_MODE="${9:-false}"
-INTERACTIVE_MODE="${10:-false}"
-TASKS_MODE="${11:-false}"
-VERIFY_MODE="${12:-false}"
-BRANCH_NAME="${13:-}"
-ORIGINAL_INPUT="${14:-}"
+FEATURE_NAME="${1:-}"
+TASK_DESCRIPTION="${2:-}"
 
-# Validate required arguments
-if [[ -z "$FEATURE_NAME" ]]; then
-    echo "Error: FEATURE_NAME is required"
-    exit 1
-fi
-
-if [[ -z "$TASK_DESCRIPTION" ]]; then
-    echo "Error: TASK_DESCRIPTION is required"
-    exit 1
-fi
-
-# Get current timestamp
-TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
-
-# Use current working directory as project root
-PROJECT_ROOT=$(pwd)
-APEX_OUTPUT_DIR="${PROJECT_ROOT}/.claude/output/apex"
-
-# Create apex output directory if it doesn't exist
-mkdir -p "$APEX_OUTPUT_DIR"
-
-# Find the next available number
-NEXT_NUM=1
-if [[ -d "$APEX_OUTPUT_DIR" ]]; then
-    # Find highest existing number prefix
-    HIGHEST=$(ls -1 "$APEX_OUTPUT_DIR" 2>/dev/null | grep -oE '^[0-9]+' | sort -n | tail -1)
-    if [[ -n "$HIGHEST" ]]; then
-        # Force base-10 interpretation (leading zeros would be treated as octal)
-        NEXT_NUM=$((10#$HIGHEST + 1))
-    fi
-fi
-
-# Format with leading zeros (2 digits)
-TASK_NUM=$(printf "%02d" "$NEXT_NUM")
-
-# Build full task ID
-TASK_ID="${TASK_NUM}-${FEATURE_NAME}"
-
-OUTPUT_DIR="${APEX_OUTPUT_DIR}/${TASK_ID}"
-
-# Get skill directory
-SKILL_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-TEMPLATE_DIR="${SKILL_DIR}/templates"
-
-# Create output directory
-mkdir -p "$OUTPUT_DIR"
-
-# Function to replace template variables
-render_template() {
-    local template_file="$1"
-    local output_file="$2"
-
-    # Determine status strings based on flags
-    local examine_status="⏭ Skip"
-    [[ "$EXAMINE_MODE" == "true" ]] && examine_status="⏸ Pending"
-
-    local test_status="⏭ Skip"
-    [[ "$TEST_MODE" == "true" ]] && test_status="⏸ Pending"
-
-    local pr_status="⏭ Skip"
-    [[ "$PR_MODE" == "true" ]] && pr_status="⏸ Pending"
-
-    local verify_status="⏭ Skip"
-    [[ "$VERIFY_MODE" == "true" ]] && verify_status="⏸ Pending"
-
-    local tasks_status="⏭ Skip"
-    [[ "$TASKS_MODE" == "true" ]] && tasks_status="⏸ Pending"
-
-    # Read template and replace variables
-    sed -e "s|{{task_id}}|${TASK_ID}|g" \
-        -e "s|{{task_description}}|${TASK_DESCRIPTION}|g" \
-        -e "s|{{timestamp}}|${TIMESTAMP}|g" \
-        -e "s|{{auto_mode}}|${AUTO_MODE}|g" \
-        -e "s|{{examine_mode}}|${EXAMINE_MODE}|g" \
-        -e "s|{{save_mode}}|${SAVE_MODE}|g" \
-        -e "s|{{test_mode}}|${TEST_MODE}|g" \
-        -e "s|{{economy_mode}}|${ECONOMY_MODE}|g" \
-        -e "s|{{branch_mode}}|${BRANCH_MODE}|g" \
-        -e "s|{{pr_mode}}|${PR_MODE}|g" \
-        -e "s|{{interactive_mode}}|${INTERACTIVE_MODE}|g" \
-        -e "s|{{tasks_mode}}|${TASKS_MODE}|g" \
-        -e "s|{{verify_mode}}|${VERIFY_MODE}|g" \
-        -e "s|{{branch_name}}|${BRANCH_NAME}|g" \
-        -e "s|{{original_input}}|${ORIGINAL_INPUT}|g" \
-        -e "s|{{examine_status}}|${examine_status}|g" \
-        -e "s|{{test_status}}|${test_status}|g" \
-        -e "s|{{tasks_status}}|${tasks_status}|g" \
-        -e "s|{{verify_status}}|${verify_status}|g" \
-        -e "s|{{pr_status}}|${pr_status}|g" \
-        "$template_file" > "$output_file"
-}
-
-# Initialize 00-context.md
-render_template "${TEMPLATE_DIR}/00-context.md" "${OUTPUT_DIR}/00-context.md"
-
-# Initialize other step files (only headers, content appended during execution)
-render_template "${TEMPLATE_DIR}/01-analyze.md" "${OUTPUT_DIR}/01-analyze.md"
-render_template "${TEMPLATE_DIR}/02-plan.md" "${OUTPUT_DIR}/02-plan.md"
-render_template "${TEMPLATE_DIR}/03-execute.md" "${OUTPUT_DIR}/03-execute.md"
-render_template "${TEMPLATE_DIR}/04-validate.md" "${OUTPUT_DIR}/04-validate.md"
-
-# Conditional templates
-if [[ "$EXAMINE_MODE" == "true" ]]; then
-    render_template "${TEMPLATE_DIR}/05-examine.md" "${OUTPUT_DIR}/05-examine.md"
-    render_template "${TEMPLATE_DIR}/06-resolve.md" "${OUTPUT_DIR}/06-resolve.md"
-fi
-
-if [[ "$TEST_MODE" == "true" ]]; then
-    render_template "${TEMPLATE_DIR}/07-tests.md" "${OUTPUT_DIR}/07-tests.md"
-    render_template "${TEMPLATE_DIR}/08-run-tests.md" "${OUTPUT_DIR}/08-run-tests.md"
-fi
-
-if [[ "$VERIFY_MODE" == "true" ]]; then
-    render_template "${TEMPLATE_DIR}/10-verify.md" "${OUTPUT_DIR}/10-verify.md"
+if [[ -z "$FEATURE_NAME" || -z "$TASK_DESCRIPTION" ]]; then
+  echo "Usage: $0 <feature-name> <task-description> [legacy-options...]" >&2
+  exit 1
 fi
 
-if [[ "$TASKS_MODE" == "true" ]]; then
-    mkdir -p "${OUTPUT_DIR}/tasks"
-fi
+PROJECT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+SKILL_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)
 
-if [[ "$PR_MODE" == "true" ]]; then
-    render_template "${TEMPLATE_DIR}/09-finish.md" "${OUTPUT_DIR}/09-finish.md"
-fi
+NEXT_NUMBER=1
+while true; do
+  RUN_ID=$(printf "%02d-%s" "$NEXT_NUMBER" "$FEATURE_NAME")
+  if RESULT=$(python3 "${SKILL_DIR}/scripts/apex-state.py" init \
+    --root "$PROJECT_ROOT" \
+    --task "$TASK_DESCRIPTION" \
+    --run-id "$RUN_ID" 2>&1); then
+    break
+  fi
+  if [[ "$RESULT" != *"run already exists"* ]]; then
+    echo "$RESULT" >&2
+    exit 1
+  fi
+  NEXT_NUMBER=$((NEXT_NUMBER + 1))
+done
 
-# Output the generated task_id for capture by caller
-echo "TASK_ID=${TASK_ID}"
+OUTPUT_DIR=$(python3 -c 'import json,sys; print(json.load(sys.stdin)["run_dir"])' <<<"$RESULT")
+echo "TASK_ID=${RUN_ID}"
 echo "OUTPUT_DIR=${OUTPUT_DIR}"
-echo "✓ APEX templates initialized: ${OUTPUT_DIR}"
-exit 0
+echo "APEX run initialized: ${OUTPUT_DIR}"

package/agents-config/skills/apex/scripts/test_apex_state.py

@@ -0,0 +1,413 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+import json
+import stat
+import subprocess
+import sys
+import tempfile
+import unittest
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+
+SCRIPT = Path(__file__).with_name("apex-state.py")
+SETUP_SCRIPT = Path(__file__).with_name("setup-templates.sh")
+UPDATE_SCRIPT = Path(__file__).with_name("update-progress.sh")
+
+
+class ApexStateTest(unittest.TestCase):
+    def setUp(self) -> None:
+        self.temporary = tempfile.TemporaryDirectory()
+        self.root = Path(self.temporary.name)
+
+    def tearDown(self) -> None:
+        self.temporary.cleanup()
+
+    def run_cli(self, *arguments: str, check: bool = True) -> subprocess.CompletedProcess[str]:
+        return subprocess.run(
+            [sys.executable, str(SCRIPT), *arguments],
+            check=check,
+            capture_output=True,
+            text=True,
+        )
+
+    def initialize(self, task: str = "Test durable state") -> dict:
+        result = self.run_cli(
+            "init",
+            "--root",
+            str(self.root),
+            "--task",
+            task,
+            "--run-id",
+            "test-run",
+        )
+        return json.loads(result.stdout)
+
+    @property
+    def directory(self) -> Path:
+        return self.root / ".agents/apex/runs/test-run"
+
+    def test_full_artifact_lifecycle_and_journal_recovery(self) -> None:
+        initialized = self.initialize()
+        self.assertEqual(initialized["run_id"], "test-run")
+        self.assertNotIn("state", initialized)
+
+        self.run_cli(
+            "event",
+            "--root",
+            str(self.root),
+            "--run-id",
+            "test-run",
+            "--phase",
+            "analyze",
+            "--status",
+            "complete",
+            "--message",
+            "Analysis complete",
+        )
+        self.run_cli(
+            "checkpoint",
+            "--root",
+            str(self.root),
+            "--run-id",
+            "test-run",
+            "--phase",
+            "plan",
+            "--message",
+            "Plan ready",
+        )
+
+        artifact = json.loads(
+            self.run_cli(
+                "artifact",
+                "--root",
+                str(self.root),
+                "--run-id",
+                "test-run",
+                "--path",
+                str(self.directory / "tasks.json"),
+                "--type",
+                "task-graph",
+                "--phase",
+                "plan",
+            ).stdout
+        )
+        self.assertEqual(artifact["status"], "current")
+
+        invalidated = json.loads(
+            self.run_cli(
+                "invalidate",
+                "--root",
+                str(self.root),
+                "--run-id",
+                "test-run",
+                "--artifact-id",
+                artifact["id"],
+                "--message",
+                "Plan changed",
+            ).stdout
+        )
+        self.assertEqual(invalidated["status"], "invalidated")
+
+        # Corrupt projections, then prove status recovers from the journal.
+        projected = json.loads((self.directory / "run.json").read_text())
+        projected["last_event_id"] = "stale"
+        (self.directory / "run.json").write_text(json.dumps(projected))
+        (self.directory / "evidence.json").write_text('{"schema_version": 1, "artifacts": []}')
+
+        status = json.loads(
+            self.run_cli("status", "--root", str(self.root), "--run-id", "test-run").stdout
+        )
+        self.assertNotEqual(status["state"]["last_event_id"], "stale")
+        self.assertEqual(status["evidence"]["artifacts"][0]["status"], "invalidated")
+        self.assertFalse(status["drift"]["known"])
+
+    def test_concurrent_events_keep_unique_ids(self) -> None:
+        self.initialize()
+
+        def record(number: int) -> None:
+            self.run_cli(
+                "event",
+                "--root",
+                str(self.root),
+                "--run-id",
+                "test-run",
+                "--phase",
+                "execute",
+                "--status",
+                "complete",
+                "--message",
+                f"Event {number}",
+            )
+
+        with ThreadPoolExecutor(max_workers=6) as executor:
+            list(executor.map(record, range(12)))
+
+        events = [json.loads(line) for line in (self.directory / "journal.jsonl").read_text().splitlines()]
+        ids = [event["id"] for event in events]
+        self.assertEqual(len(ids), 13)
+        self.assertEqual(len(set(ids)), 13)
+
+    def test_concurrent_init_has_one_winner(self) -> None:
+        def initialize(_: int) -> int:
+            return self.run_cli(
+                "init",
+                "--root",
+                str(self.root),
+                "--task",
+                "Concurrent",
+                "--run-id",
+                "same-run",
+                check=False,
+            ).returncode
+
+        with ThreadPoolExecutor(max_workers=2) as executor:
+            results = list(executor.map(initialize, range(2)))
+        self.assertEqual(sorted(results), [0, 1])
+        self.assertEqual(list((self.root / ".agents/apex/runs").glob(".initializing-*")), [])
+
+    def test_concurrent_distinct_init_on_fresh_root(self) -> None:
+        def initialize(number: int) -> int:
+            return self.run_cli(
+                "init",
+                "--root",
+                str(self.root),
+                "--task",
+                f"Concurrent {number}",
+                "--run-id",
+                f"run-{number}",
+                check=False,
+            ).returncode
+
+        with ThreadPoolExecutor(max_workers=2) as executor:
+            results = list(executor.map(initialize, range(2)))
+        self.assertEqual(results, [0, 0])
+
+    def test_rejects_symlinked_state_root(self) -> None:
+        outside = self.root / "outside"
+        outside.mkdir()
+        (self.root / ".agents").symlink_to(outside, target_is_directory=True)
+        result = self.run_cli(
+            "init",
+            "--root",
+            str(self.root),
+            "--task",
+            "Symlink",
+            "--run-id",
+            "test-run",
+            check=False,
+        )
+        self.assertNotEqual(result.returncode, 0)
+        self.assertIn("symlink", result.stderr)
+
+    def test_redacts_secrets_and_uses_private_modes(self) -> None:
+        secret = "sk-abcdefghijklmnopqrstuv"
+        self.initialize(f"Fix auth token={secret}")
+        state_text = (self.directory / "run.json").read_text()
+        self.assertNotIn(secret, state_text)
+        self.assertIn("[REDACTED_SECRET]", state_text)
+        self.assertEqual(stat.S_IMODE(self.directory.stat().st_mode), 0o700)
+        for name in ("run.json", "tasks.json", "evidence.json", "journal.jsonl"):
+            self.assertEqual(stat.S_IMODE((self.directory / name).stat().st_mode), 0o600)
+
+    def test_rejects_secrets_in_metadata(self) -> None:
+        self.initialize()
+        secret = "sk-abcdefghijklmnopqrstuv"
+        for field, value in (("--task-id", secret), ("--phase", secret)):
+            arguments = [
+                "event",
+                "--root",
+                str(self.root),
+                "--run-id",
+                "test-run",
+                "--phase",
+                "execute",
+                "--status",
+                "complete",
+                "--message",
+                "Safe",
+            ]
+            index = arguments.index(field) if field in arguments else None
+            if index is None:
+                arguments.extend((field, value))
+            else:
+                arguments[index + 1] = value
+            result = self.run_cli(*arguments, check=False)
+            self.assertNotEqual(result.returncode, 0)
+            self.assertNotIn(secret, result.stderr)
+
+        artifact_path = self.directory / f"token={secret}"
+        artifact_path.write_text("sensitive name")
+        result = self.run_cli(
+            "artifact",
+            "--root",
+            str(self.root),
+            "--run-id",
+            "test-run",
+            "--path",
+            str(artifact_path),
+            "--type",
+            "task-graph",
+            "--phase",
+            "plan",
+            check=False,
+        )
+        self.assertNotEqual(result.returncode, 0)
+        self.assertNotIn(secret, result.stderr)
+
+    def test_tampered_artifact_is_reported_stale(self) -> None:
+        self.initialize()
+        artifact_path = self.directory / "tasks.json"
+        artifact = json.loads(
+            self.run_cli(
+                "artifact",
+                "--root",
+                str(self.root),
+                "--run-id",
+                "test-run",
+                "--path",
+                str(artifact_path),
+                "--type",
+                "task-graph",
+                "--phase",
+                "plan",
+            ).stdout
+        )
+        artifact_path.write_text('{"tampered": true}')
+        status = json.loads(
+            self.run_cli("status", "--root", str(self.root), "--run-id", "test-run").stdout
+        )
+        current = next(item for item in status["evidence"]["artifacts"] if item["id"] == artifact["id"])
+        self.assertEqual(current["status"], "stale")
+        self.assertEqual(current["integrity"], "mismatch")
+
+    def test_unborn_git_revision_makes_drift_unknown(self) -> None:
+        subprocess.run(["git", "init", "-q", str(self.root)], check=True)
+        self.initialize()
+        status = json.loads(
+            self.run_cli("status", "--root", str(self.root), "--run-id", "test-run").stdout
+        )
+        self.assertFalse(status["state"]["baseline"]["verified"])
+        self.assertFalse(status["drift"]["known"])
+
+    def test_redacted_git_paths_still_produce_known_drift(self) -> None:
+        subprocess.run(["git", "init", "-q", str(self.root)], check=True)
+        subprocess.run(["git", "-C", str(self.root), "config", "user.email", "test@example.com"], check=True)
+        subprocess.run(["git", "-C", str(self.root), "config", "user.name", "APEX Test"], check=True)
+        tracked = self.root / "tracked.txt"
+        tracked.write_text("baseline")
+        subprocess.run(["git", "-C", str(self.root), "add", "tracked.txt"], check=True)
+        subprocess.run(["git", "-C", str(self.root), "commit", "-qm", "test baseline"], check=True)
+        before = self.root / "secret=old"
+        before.write_text("before")
+        self.initialize()
+        before.unlink()
+        (self.root / "secret=new").write_text("after")
+
+        status = json.loads(
+            self.run_cli("status", "--root", str(self.root), "--run-id", "test-run").stdout
+        )
+        self.assertTrue(status["state"]["baseline"]["paths_redacted"])
+        self.assertTrue(status["drift"]["known"])
+        self.assertTrue(status["drift"]["changes_changed"])
+
+    def test_redacted_branch_names_still_produce_known_drift(self) -> None:
+        subprocess.run(["git", "init", "-q", str(self.root)], check=True)
+        subprocess.run(["git", "-C", str(self.root), "config", "user.email", "test@example.com"], check=True)
+        subprocess.run(["git", "-C", str(self.root), "config", "user.name", "APEX Test"], check=True)
+        tracked = self.root / "tracked.txt"
+        tracked.write_text("baseline")
+        subprocess.run(["git", "-C", str(self.root), "add", "tracked.txt"], check=True)
+        subprocess.run(["git", "-C", str(self.root), "commit", "-qm", "test baseline"], check=True)
+        subprocess.run(["git", "-C", str(self.root), "checkout", "-qb", "secret=old"], check=True)
+        self.initialize()
+        subprocess.run(["git", "-C", str(self.root), "checkout", "-qb", "secret=new"], check=True)
+
+        status = json.loads(
+            self.run_cli("status", "--root", str(self.root), "--run-id", "test-run").stdout
+        )
+        self.assertTrue(status["drift"]["known"])
+        self.assertTrue(status["drift"]["branch_changed"])
+
+    def test_terminal_status_survives_final_checkpoint(self) -> None:
+        self.initialize()
+        self.run_cli(
+            "event",
+            "--root",
+            str(self.root),
+            "--run-id",
+            "test-run",
+            "--phase",
+            "handoff",
+            "--status",
+            "complete",
+            "--message",
+            "Complete",
+        )
+        self.run_cli(
+            "checkpoint",
+            "--root",
+            str(self.root),
+            "--run-id",
+            "test-run",
+            "--phase",
+            "handoff",
+            "--message",
+            "Final checkpoint",
+        )
+        status = json.loads(
+            self.run_cli("status", "--root", str(self.root), "--run-id", "test-run").stdout
+        )
+        self.assertEqual(status["state"]["status"], "complete")
+
+    def test_legacy_wrappers_keep_numbered_id_and_output_contract(self) -> None:
+        first = subprocess.run(
+            ["bash", str(SETUP_SCRIPT), "legacy-feature", "Legacy task"],
+            cwd=self.root,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        values = dict(
+            line.split("=", 1)
+            for line in first.stdout.splitlines()
+            if line.startswith(("TASK_ID=", "OUTPUT_DIR="))
+        )
+        self.assertEqual(values["TASK_ID"], "01-legacy-feature")
+        self.assertTrue(Path(values["OUTPUT_DIR"]).is_dir())
+
+        subprocess.run(
+            ["bash", str(UPDATE_SCRIPT), values["TASK_ID"], "01", "analyze", "complete"],
+            cwd=self.root,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        second = subprocess.run(
+            ["bash", str(SETUP_SCRIPT), "legacy-feature", "Legacy task 2"],
+            cwd=self.root,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        self.assertIn("TASK_ID=02-legacy-feature", second.stdout)
+
+    def test_rejects_invalid_run_id(self) -> None:
+        result = self.run_cli(
+            "init",
+            "--root",
+            str(self.root),
+            "--task",
+            "Invalid",
+            "--run-id",
+            "../escape",
+            check=False,
+        )
+        self.assertNotEqual(result.returncode, 0)
+        self.assertIn("run ID", result.stderr)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/agents-config/skills/apex/scripts/update-progress.sh

@@ -1,80 +1,24 @@
 #!/bin/bash
-# APEX Progress Update Script
-# Updates 00-context.md progress table
+# Backward-compatible progress event writer for older APEX callers.
 
-set -e
+set -euo pipefail
 
-# Arguments
-TASK_ID="$1"
-STEP_NUMBER="$2"
-STEP_NAME="$3"
-STATUS="$4"  # "in_progress" or "complete"
+RUN_ID="${1:-}"
+STEP_NUMBER="${2:-}"
+STEP_NAME="${3:-}"
+STATUS="${4:-}"
 
-# Validate required arguments
-if [[ -z "$TASK_ID" ]] || [[ -z "$STEP_NUMBER" ]] || [[ -z "$STEP_NAME" ]] || [[ -z "$STATUS" ]]; then
-    echo "Usage: $0 <task_id> <step_number> <step_name> <status>"
-    echo "Example: $0 01-add-auth 01 analyze complete"
-    exit 1
+if [[ -z "$RUN_ID" || -z "$STEP_NUMBER" || -z "$STEP_NAME" || -z "$STATUS" ]]; then
+  echo "Usage: $0 <run-id> <step-number> <step-name> <status>" >&2
+  exit 1
 fi
 
-# Find project root
 PROJECT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
-CONTEXT_FILE="${PROJECT_ROOT}/.claude/output/apex/${TASK_ID}/00-context.md"
-
-# Validate context file exists
-if [[ ! -f "$CONTEXT_FILE" ]]; then
-    echo "Error: Context file not found: $CONTEXT_FILE"
-    exit 1
-fi
-
-# Get timestamp
-TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
-
-# Determine status symbol
-if [[ "$STATUS" == "in_progress" ]]; then
-    STATUS_SYMBOL="⏳ In Progress"
-elif [[ "$STATUS" == "complete" ]]; then
-    STATUS_SYMBOL="✓ Complete"
-else
-    echo "Error: Invalid status. Use 'in_progress' or 'complete'"
-    exit 1
-fi
-
-# Create temp file
-TEMP_FILE=$(mktemp)
-
-# Update the progress table
-awk -v step="${STEP_NUMBER}-${STEP_NAME}" \
-    -v status="$STATUS_SYMBOL" \
-    -v timestamp="$TIMESTAMP" '
-BEGIN { in_table = 0; found = 0 }
-{
-    # Detect progress table start
-    if ($0 ~ /^## Progress/) {
-        in_table = 1
-        print $0
-        next
-    }
-
-    # If in table and found the matching step
-    if (in_table && $0 ~ "\\| " step " \\|") {
-        printf "| %s | %s | %s |\n", step, status, timestamp
-        found = 1
-        next
-    }
-
-    # Print line as-is
-    print $0
-}
-END {
-    if (!found) {
-        print "Warning: Step not found in progress table" > "/dev/stderr"
-    }
-}
-' "$CONTEXT_FILE" > "$TEMP_FILE"
-
-# Replace original file
-mv "$TEMP_FILE" "$CONTEXT_FILE"
-
-echo "✓ Progress updated: ${STEP_NUMBER}-${STEP_NAME} → ${STATUS_SYMBOL}"
-exit 0
+SKILL_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)
+
+python3 "${SKILL_DIR}/scripts/apex-state.py" event \
+  --root "$PROJECT_ROOT" \
+  --run-id "$RUN_ID" \
+  --phase "$STEP_NAME" \
+  --status "$STATUS" \
+  --message "Legacy progress update ${STEP_NUMBER}-${STEP_NAME}"