Add OpenCode/Claude compat: generate CLAUDE.md, symlink skills, merge fix-workflow-first

Author: j0ntz

.cursor/rules/fix-workflow-first.mdc

@@ -5,14 +5,48 @@ alwaysApply: true
 
 <rules description="Non-negotiable constraints.">
 
+<rule id="skill-script-path-resolution">When a skill mentions a script path, resolve it under `~/.cursor/skills/<skill>/scripts/` unless the skill explicitly specifies an absolute path elsewhere. Do not assume repo-relative `scripts/` paths without verifying the skill directory contents.</rule>
+
 <rule id="halt-on-error">When ANY shell command fails (non-zero exit code) during a workflow:
 1. **STOP** — do not retry, work around, substitute, or continue the workflow.
 2. **Report** — show the user the exact command, exit code, and error output.
 3. **Diagnose** — classify the failure: missing tool (`command not found`), wrong path, permissions, or logic error.
-4. **Evaluate workflow** — if the failure reveals a gap in a command/skill definition, read `~/.cursor/rules/fix-workflow-first.mdc` and follow it.
+4. **Evaluate workflow** — if the failure reveals a gap in a skill definition, follow the fix-workflow-first rules below.
 5. **Wait** — do not resume until the user responds.
 </rule>
 
+<rule id="fix-workflow-first">When a workflow gap is discovered in a skill definition:
+1. **Stop immediately** — do not continue the current task or apply any workaround.
+2. **Identify the root cause** in the skill (`.cursor/skills/*/SKILL.md`) definition.
+3. **Propose the fix** to the user and wait for approval before proceeding.
+4. **Fix the skill** using `/author` after approval.
+5. **Resume the original task** only after the skill is updated.
+
+Fixing the skill takes **absolute priority** over all other actions — including workarounds, continuing the original task, or applying temporary fixes. Do NOT apply workarounds or manual fixes before proposing the skill update. The correct sequence is: identify gap → propose fix → get approval → apply fix → then resume original task. This applies to all workflow issues — missed steps, incorrect output, wrong tool usage, shell failures, formatting problems, etc. The skill is the source of truth; patching around it creates drift.
+</rule>
+
+<rule id="auto-fix-verification-failures">Exception to `halt-on-error`: For verification/code-quality failures where diagnostics are explicit and local, continue automatically with bounded remediation.
+
+Allowed auto-fix scope:
+- TypeScript/compiler failures (`tsc`) with clear file/line diagnostics
+- Lint failures (`eslint`) with clear file/line diagnostics
+- Test failures (`jest`/`yarn test`) when stack traces or assertion output identify failing test files
+- `verify-repo.sh` code-step failures that resolve to one of the above
+
+Required behavior:
+1. Briefly log rationale: failure type, affected files, and why scope is unambiguous.
+2. Apply the minimal fix in the failing repo.
+3. Re-run the failing verification step.
+4. Limit to 2 remediation attempts; if still failing or scope expands, fall back to `halt-on-error`.
+
+Never auto-fix:
+- Missing tools/auth (`command not found`, `PROMPT_GH_AUTH`)
+- Wrong path/permissions
+- Companion script contract/usage failures
+- Unexpected exit codes from orchestrator scripts
+- Any failure requiring destructive operations or workflow bypasses
+</rule>
+
 <rule id="no-silent-substitution">Do NOT silently substitute an alternative tool or approach when a command fails. If `rg` is not found, do not fall back to `grep`. If a script exits non-zero, do not manually replicate what the script does. The failure is the signal — report it.</rule>
 
 </rules>

.cursor/rules/workflow-halt-on-error.mdc

@@ -6,13 +6,14 @@ metadata:
   author: j0ntz
 ---
 
-<goal>Sync cursor files between `~/.cursor/` and the `edge-conventions` repo, commit, push, and update PR description from README.</goal>
+<goal>Sync cursor files between `~/.cursor/` and the `edge-conventions` repo, commit, push, and update PR description from README. Also maintains cross-tool compatibility: symlinks `~/.claude/skills` → `~/.cursor/skills` and generates `~/.claude/CLAUDE.md` from always-apply rules.</goal>
 
 <rules>
 <rule id="use-companion-script">Use `scripts/convention-sync.sh` for diffing and syncing. Do NOT manually diff or copy files.</rule>
 <rule id="dry-run-first">Always run without `--stage` first to show the summary. Only stage/commit after user confirms.</rule>
 <rule id="no-script-bypass">If the script fails, report the error and STOP.</rule>
 <rule id="readme-is-source">`.cursor/README.md` is the source of truth for documentation. The script mirrors it to the PR description automatically.</rule>
+<rule id="claude-compat">Every run ensures `~/.claude/skills` symlinks to `~/.cursor/skills` and regenerates `~/.claude/CLAUDE.md` from `alwaysApply: true` rules. This enables OpenCode and Claude Code to discover skills and rules without separate config.</rule>
 </rules>
 
 <step id="1" name="Detect changes and PR status">

.cursor/skills/convention-sync/SKILL.md

@@ -113,6 +113,26 @@ done
 
 total=$(echo "$new_json $mod_json $del_json" | jq -s '.[0] + .[1] + .[2] | length')
 
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Ensure ~/.claude/skills symlink points to ~/.cursor/skills
+CLAUDE_SKILLS="$HOME/.claude/skills"
+if [[ -L "$CLAUDE_SKILLS" ]]; then
+  link_target="$(readlink "$CLAUDE_SKILLS")"
+  if [[ "$link_target" != "$USER_DIR/skills" ]]; then
+    rm "$CLAUDE_SKILLS"
+    ln -s "$USER_DIR/skills" "$CLAUDE_SKILLS"
+  fi
+elif [[ ! -e "$CLAUDE_SKILLS" ]]; then
+  mkdir -p "$(dirname "$CLAUDE_SKILLS")"
+  ln -s "$USER_DIR/skills" "$CLAUDE_SKILLS"
+fi
+
+# Regenerate ~/.claude/CLAUDE.md from alwaysApply rules
+if [[ -x "$SCRIPT_DIR/generate-claude-md.sh" ]]; then
+  "$SCRIPT_DIR/generate-claude-md.sh" >/dev/null
+fi
+
 if [[ "$DO_STAGE" == true && "$total" -gt 0 ]]; then
   all_copy=$(echo "$new_json $mod_json" | jq -sr '.[0] + .[1] | .[]')
   all_del=$(echo "$del_json" | jq -r '.[]')

.cursor/skills/convention-sync/scripts/convention-sync.sh

@@ -0,0 +1,85 @@
+#!/usr/bin/env bash
+# generate-claude-md.sh — Generate ~/.claude/CLAUDE.md from alwaysApply .mdc rules.
+# Usage: ./generate-claude-md.sh [--dry-run]
+#
+# Reads all .mdc files in ~/.cursor/rules/ that have alwaysApply: true,
+# strips YAML frontmatter, and concatenates them into ~/.claude/CLAUDE.md.
+
+set -euo pipefail
+
+RULES_DIR="$HOME/.cursor/rules"
+OUTPUT="$HOME/.claude/CLAUDE.md"
+DRY_RUN=false
+
+[[ "${1:-}" == "--dry-run" ]] && DRY_RUN=true
+
+if [[ ! -d "$RULES_DIR" ]]; then
+  echo "ERROR: $RULES_DIR does not exist" >&2
+  exit 1
+fi
+
+mkdir -p "$(dirname "$OUTPUT")"
+
+collected=()
+skipped=()
+
+for mdc in "$RULES_DIR"/*.mdc; do
+  [[ -f "$mdc" ]] || continue
+  basename="$(basename "$mdc")"
+
+  if head -20 "$mdc" | grep -q '^alwaysApply: true'; then
+    collected+=("$basename")
+  else
+    skipped+=("$basename")
+  fi
+done
+
+if [[ ${#collected[@]} -eq 0 ]]; then
+  echo '{"collected":[],"skipped":[],"output":"","dry_run":true}'
+  exit 0
+fi
+
+content="# Global Rules\n\n"
+content+="# Auto-generated from ~/.cursor/rules/ (alwaysApply: true files only).\n"
+content+="# Do not edit manually. Re-generate via convention-sync.\n\n"
+
+for basename in "${collected[@]}"; do
+  mdc="$RULES_DIR/$basename"
+  name="${basename%.mdc}"
+
+  # Strip YAML frontmatter (everything between first --- and second ---)
+  body=$(awk '
+    BEGIN { in_front=0; past_front=0 }
+    /^---$/ {
+      if (!past_front) {
+        if (in_front) { past_front=1; next }
+        else { in_front=1; next }
+      }
+    }
+    past_front { print }
+  ' "$mdc")
+
+  # Trim leading blank lines
+  body=$(echo "$body" | sed '/./,$!d')
+
+  content+="---\n\n"
+  content+="## $name\n\n"
+  content+="$body\n\n"
+done
+
+if [[ "$DRY_RUN" == true ]]; then
+  echo -e "$content" > /dev/null
+else
+  echo -e "$content" > "$OUTPUT"
+fi
+
+# Output JSON summary
+collected_json=$(printf '%s\n' "${collected[@]}" | jq -R . | jq -s .)
+skipped_json=$(printf '%s\n' "${skipped[@]}" | jq -R . | jq -s .)
+
+jq -n \
+  --argjson collected "$collected_json" \
+  --argjson skipped "$skipped_json" \
+  --arg output "$OUTPUT" \
+  --arg dry_run "$DRY_RUN" \
+  '{collected: $collected, skipped: $skipped, output: $output, dry_run: ($dry_run == "true")}'

.cursor/skills/convention-sync/scripts/generate-claude-md.sh

@@ -13,7 +13,7 @@ metadata:
 <rule id="check-existence">Always check if a dependent task already exists before creating one. The script handles this — respect the `CREATED: false` output.</rule>
 <rule id="script-timeouts">Asana scripts can take up to 90s. Always set `block_until_ms: 120000`.</rule>
 <rule id="no-impl-before-task">Do NOT begin implementation until the dependent task is created and linked.</rule>
-<rule id="same-project">The dependent task MUST be created in the same non-version project(s) as the parent task. The script handles this automatically — it copies all non-version project memberships from the parent.</rule>
+<rule id="same-project">The dependent task MUST be created in the same project(s) as the parent task, including release-version project tags (for example `4.46.0`). The script handles this automatically by copying all parent project memberships.</rule>
 <rule id="initial-assignee">The dependent task is automatically assigned to the current user (resolved via `asana-whoami.sh`). Do NOT hardcode a user GID — omit `--assignee` to let the script auto-resolve.</rule>
 </rules>
 
@@ -66,16 +66,16 @@ Derive the dependent task name from the parent: `<target-prefix>: <parent task n
 If the parent task name already has a prefix (e.g. `gui: Some feature`), strip it and replace with the target prefix. If no prefix, prepend the target prefix.
 
 ```bash
-scripts/asana-create-dep-task.sh \
+~/.cursor/skills/dep-pr/scripts/asana-create-dep-task.sh \
   --parent <parent_gid> \
   --name "<prefix>: <task name>" \
   --notes "<description referencing parent task>"
 ```
 
 The script:
 - Checks if a matching dependency already exists (by name) — if so, outputs `CREATED: false` and the existing GID
-- Creates the task in the parent's non-version project(s)
-- Copies priority and status from the parent
+- Creates the task in all parent project memberships (including release-version tags)
+- Copies priority, status, and `Planned` from the parent
 - Assigns to the current user (auto-resolved via `asana-whoami.sh`)
 - Sets the new task as a blocking dependency of the parent
 

.cursor/skills/dep-pr/SKILL.md

@@ -16,7 +16,7 @@
 #   TASK_URL: <url>
 #   CREATED: true|false (false if task already existed)
 #   ASSIGNED_TO: <user_gid>
-#   FIELDS_SET: priority=<val>, status=<val>, reviewer=<name>, implementor=<name>
+#   FIELDS_SET: priority=<val>, status=<val>, planned=<val>, reviewer=<name>, implementor=<name>
 #   DEPENDENCY_SET: <new_gid> blocks <parent_gid>
 #
 # Exit codes: 0 = success, 1 = error
@@ -84,22 +84,23 @@ fi
 parent_info=$(curl -s "$API/tasks/$PARENT_GID?opt_fields=workspace.gid,memberships.project.gid,memberships.project.name,custom_fields.gid,custom_fields.enum_value.gid,custom_fields.enum_value.name,custom_fields.people_value.gid,custom_fields.people_value.name" \
   -H "$AUTH")
 
-read -r WORKSPACE_GID PROJECT_GIDS PRIORITY_INFO STATUS_INFO REVIEWER_INFO < <(echo "$parent_info" | python3 -c "
+read -r WORKSPACE_GID PROJECT_GIDS PRIORITY_INFO STATUS_INFO PLANNED_INFO REVIEWER_INFO < <(echo "$parent_info" | python3 -c "
 import sys, json, re
 data = json.load(sys.stdin)['data']
 ws = data.get('workspace', {}).get('gid', '')
 
-# Collect all non-version projects (board/backlog projects, not release milestones)
+# Collect all parent projects (including release-version projects like 4.46.0)
 projects = []
 for m in data.get('memberships', []):
     p = m.get('project', {})
-    if not re.match(r'^\d+\.\d+\.\d+$', p.get('name', '')):
-        projects.append(p.get('gid', ''))
+    gid = p.get('gid', '')
+    if gid:
+        projects.append(gid)
 if not projects and data.get('memberships'):
     projects.append(data['memberships'][0]['project']['gid'])
 proj_str = ','.join(projects)
 
-# Field GIDs
+# Field GIDs (stable known fields)
 ENUM_FIELDS = {
     '795866930204488': 'priority',
     '1190660107346181': 'status',
@@ -116,6 +117,13 @@ for f in data.get('custom_fields', []):
     if fgid in ENUM_FIELDS and f.get('enum_value'):
         label = ENUM_FIELDS[fgid]
         enum_results[label] = (fgid, f['enum_value']['gid'], f['enum_value'].get('name', ''))
+    # "Planned" is workspace-specific, so detect by field name:
+    if f.get('name') == 'Planned' and f.get('enum_value'):
+        enum_results['planned'] = (
+            fgid,
+            f['enum_value']['gid'],
+            f['enum_value'].get('name', '')
+        )
     if fgid in PEOPLE_FIELDS:
         label = PEOPLE_FIELDS[fgid]
         pv = f.get('people_value', [])
@@ -132,7 +140,7 @@ def fmt_people(key):
         return ':'.join(people_results[key])
     return '::'
 
-print(f\"{ws} {proj_str} {fmt_enum('priority')} {fmt_enum('status')} {fmt_people('reviewer')}\")
+print(f\"{ws} {proj_str} {fmt_enum('priority')} {fmt_enum('status')} {fmt_enum('planned')} {fmt_people('reviewer')}\")
 ")
 
 PRIORITY_FIELD=$(echo "$PRIORITY_INFO" | cut -d: -f1)
@@ -141,6 +149,9 @@ PRIORITY_NAME=$(echo "$PRIORITY_INFO" | cut -d: -f3)
 STATUS_FIELD=$(echo "$STATUS_INFO" | cut -d: -f1)
 STATUS_ENUM=$(echo "$STATUS_INFO" | cut -d: -f2)
 STATUS_NAME=$(echo "$STATUS_INFO" | cut -d: -f3)
+PLANNED_FIELD=$(echo "$PLANNED_INFO" | cut -d: -f1)
+PLANNED_ENUM=$(echo "$PLANNED_INFO" | cut -d: -f2)
+PLANNED_NAME=$(echo "$PLANNED_INFO" | cut -d: -f3)
 REVIEWER_FIELD=$(echo "$REVIEWER_INFO" | cut -d: -f1)
 REVIEWER_GID=$(echo "$REVIEWER_INFO" | cut -d: -f2)
 REVIEWER_NAME=$(echo "$REVIEWER_INFO" | cut -d: -f3)
@@ -159,8 +170,10 @@ import json
 cf = {}
 pf, pe = '$PRIORITY_FIELD', '$PRIORITY_ENUM'
 sf, se = '$STATUS_FIELD', '$STATUS_ENUM'
+plf, ple = '$PLANNED_FIELD', '$PLANNED_ENUM'
 if pf and pe: cf[pf] = pe
 if sf and se: cf[sf] = se
+if plf and ple: cf[plf] = ple
 print(json.dumps(cf))
 ")
 
@@ -241,6 +254,7 @@ echo "DEPENDENCY_SET: $NEW_GID blocks $PARENT_GID"
 fields_msg=""
 [[ -n "$PRIORITY_NAME" ]] && fields_msg="priority=$PRIORITY_NAME"
 [[ -n "$STATUS_NAME" ]] && fields_msg="${fields_msg:+$fields_msg, }status=$STATUS_NAME"
+[[ -n "$PLANNED_NAME" ]] && fields_msg="${fields_msg:+$fields_msg, }planned=$PLANNED_NAME"
 [[ -n "$REVIEWER_NAME" ]] && fields_msg="${fields_msg:+$fields_msg, }reviewer=$REVIEWER_NAME"
 [[ -n "$IMPLEMENTOR_GID" ]] && fields_msg="${fields_msg:+$fields_msg, }implementor=$IMPLEMENTOR_NAME"
 [[ -n "$fields_msg" ]] && echo "FIELDS_SET: $fields_msg"

.cursor/skills/dep-pr/scripts/asana-create-dep-task.sh

@@ -9,7 +9,7 @@ metadata:
 <goal>End-to-end flow: resolve an Asana task, implement it (or continue from a prior `/im` run), then create a PR with Asana linking and assignment.</goal>
 
 <rules description="Non-negotiable constraints.">
-<rule id="use-companion-script">Do NOT call `gh` or `curl` directly. Use `scripts/pr-create.sh` for PR creation (it uses `gh` internally).</rule>
+<rule id="use-companion-script">Do NOT call `gh` or `curl` directly. Use `~/.cursor/skills/pr-create/scripts/pr-create.sh` for PR creation (it uses `gh` internally).</rule>
 <rule id="no-script-bypass">If a companion script fails, report the error and STOP. Do NOT fall back to raw `gh`, `curl`, or other workarounds.</rule>
 <rule id="gh-auth-required">If any script exits code 2 with `PROMPT_GH_AUTH`, prompt the user to run `gh auth login` and STOP.</rule>
 <rule id="commit-script">Always commit using `~/.cursor/skills/lint-commit.sh -m "message" [files...]`. Never use raw `git add` + `git commit`.</rule>
@@ -178,7 +178,7 @@ Create the PR immediately — do not ask for confirmation.
    - The Write tool **overwrites** the file. ApplyPatch `Add File` may append to an existing file, causing stale content from a prior PR to bleed through. **Always use Write.**
 2. **Run the script**:
    ```bash
-   scripts/pr-create.sh --title "<title>" --body-file /tmp/pr-body.md --asana-task <task_gid>
+   ~/.cursor/skills/pr-create/scripts/pr-create.sh --title "<title>" --body-file /tmp/pr-body.md --asana-task <task_gid>
    ```
    - Pass `--asana-task <task_gid>` when an Asana task is available. The script injects a clickable Asana link into the PR body if one isn't already present. This is **required** for downstream `/pr-land` to extract the task GID.
    - The script cleans up `/tmp/pr-body.md` after use to prevent cross-PR contamination. It will be re-populated from GitHub if needed during `/pr-address`.
@@ -192,7 +192,7 @@ If the script exits code 2 with `PROMPT_GH_AUTH`, prompt the user to run `gh aut
 If no Asana link was provided, skip silently.
 
 ```bash
-scripts/asana-attach-pr.sh \
+~/.cursor/skills/pr-create/scripts/asana-attach-pr.sh \
   --task <task_gid> \
   --pr-url <pr_url> \
   --pr-title "<title>" \
@@ -211,7 +211,7 @@ By default, the script only attaches — no assignment or status change.
 With `--assign`, the script exits code 2 and outputs `PROMPT_REVIEWER` if the Reviewer field is empty. Ask the user who to assign using the team roster, then re-run with the override:
 
 ```bash
-scripts/asana-attach-pr.sh \
+~/.cursor/skills/pr-create/scripts/asana-attach-pr.sh \
   --task <task_gid> --pr-url <pr_url> --pr-title "<title>" --pr-number <number> \
   --assign --reviewer <user_gid>
 ```