ecoportal-api-graphql 1.3.5 → 1.3.9

data/.ai-assistance/scripts/bridge-init.sh

@@ -0,0 +1,86 @@
+#!/bin/bash
+# bridge-init.sh
+# Detects environment, scans bridge/inbox for pending tasks belonging to current user.
+# Output: single JSON line for the agent to consume.
+# Usage: source .ai-assistance/scripts/bridge-init.sh
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+BRIDGE_DIR="$SCRIPT_DIR/../bridge"
+INBOX_DIR="$BRIDGE_DIR/inbox"
+
+# --- Environment detection ---
+# Prefer explicit env var; fall back to "code" (this script is most useful in Code)
+ENV="${CLAUDE_ENV:-code}"
+
+# --- Username detection ---
+# Prefer explicit env var; fall back to git config
+if [ -n "${BRIDGE_USER:-}" ]; then
+  USER_SLUG="$BRIDGE_USER"
+else
+  GIT_USER=$(git config user.name 2>/dev/null || echo "unknown")
+  USER_SLUG=$(echo "$GIT_USER" | tr '[:upper:]' '[:lower:]' | tr ' ' '-' | tr -cd '[:alnum:]-')
+fi
+
+# --- Stale threshold (seconds) ---
+# IN_PROGRESS tasks older than this are flagged as stale (likely a crashed session).
+STALE_THRESHOLD_SECONDS=3600  # 1 hour
+
+# --- Scan inbox ---
+pending_tasks=()
+stale_tasks=()
+
+if [ -d "$INBOX_DIR" ]; then
+  while IFS= read -r -d '' file; do
+    filename=$(basename "$file")
+    # Only files prefixed with this user's slug
+    if [[ "$filename" == ${USER_SLUG}-* ]]; then
+      if grep -q "^STATUS: PENDING" "$file" 2>/dev/null; then
+        pending_tasks+=("$filename")
+      elif grep -q "^STATUS: IN_PROGRESS" "$file" 2>/dev/null; then
+        # Check how old the file is
+        if command -v stat &>/dev/null; then
+          # GNU stat (Linux/Git-Bash): -c %Y gives mtime as epoch seconds
+          # macOS stat uses -f %m — try GNU first, fall back gracefully
+          mtime=$(stat -c %Y "$file" 2>/dev/null || stat -f %m "$file" 2>/dev/null || echo 0)
+          now=$(date +%s)
+          age=$(( now - mtime ))
+          if [ "$age" -ge "$STALE_THRESHOLD_SECONDS" ]; then
+            stale_tasks+=("$filename")
+          fi
+        fi
+        # If stat is unavailable we silently skip stale detection for this file
+      fi
+    fi
+  done < <(find "$INBOX_DIR" -maxdepth 1 -name "*.md" \
+    -not -name "*.draft.md" \
+    -not -name "*.local.md" \
+    -not -name ".gitkeep" \
+    -print0 2>/dev/null)
+fi
+
+# --- Build JSON output ---
+count=${#pending_tasks[@]}
+stale_count=${#stale_tasks[@]}
+
+tasks_json="["
+for i in "${!pending_tasks[@]}"; do
+  tasks_json+="\"${pending_tasks[$i]}\""
+  [ $i -lt $((count - 1)) ] && tasks_json+=","
+done
+tasks_json+="]"
+
+stale_json="["
+for i in "${!stale_tasks[@]}"; do
+  stale_json+="\"${stale_tasks[$i]}\""
+  [ $i -lt $((stale_count - 1)) ] && stale_json+=","
+done
+stale_json+="]"
+
+output="{\"env\":\"$ENV\",\"user\":\"$USER_SLUG\",\"pending\":$count,\"tasks\":$tasks_json,\"stale\":$stale_count,\"stale_tasks\":$stale_json}"
+
+# Write to status file so Code can read it on startup (hook stdout is not injected into context)
+echo "$output" > "$BRIDGE_DIR/STATUS"
+
+echo "$output"

data/.ai-assistance/scripts/bridge-status.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+# bridge-status.sh
+# Quick dashboard of bridge state. One line output for agent consumption.
+#
+# Usage:
+#   bash .ai-assistance/scripts/bridge-status.sh
+#
+# Output:
+#   pending:2 in_progress:1 done:0 failed:0 archived:12 last_activity:2026-06-03T14:32Z
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+BRIDGE_DIR="$SCRIPT_DIR/../bridge"
+
+count_status() {
+  local dir="$1"
+  local pattern="$2"
+  if [ ! -d "$dir" ]; then echo 0; return; fi
+  grep -rl "^STATUS: $pattern" "$dir" --include="*.md" 2>/dev/null | wc -l | tr -d ' '
+}
+
+PENDING=$(count_status "$BRIDGE_DIR/inbox" "PENDING")
+IN_PROGRESS=$(count_status "$BRIDGE_DIR/inbox" "IN_PROGRESS")
+DONE=$(count_status "$BRIDGE_DIR/outbox" "DONE")
+FAILED=$(count_status "$BRIDGE_DIR/outbox" "FAILED")
+
+ARCHIVED=0
+if [ -d "$BRIDGE_DIR/archive" ]; then
+  ARCHIVED=$(find "$BRIDGE_DIR/archive" -name "outbox-*.md" 2>/dev/null | wc -l | tr -d ' ')
+fi
+
+# Last activity: most recently modified file in bridge/
+LAST_ACTIVITY="none"
+if command -v stat &>/dev/null; then
+  LAST_FILE=$(find "$BRIDGE_DIR" -name "*.md" -not -name ".gitkeep" \
+    -exec stat -f "%m %N" {} \; 2>/dev/null \
+    | sort -rn | head -1 | awk '{print $2}' || true)
+  if [ -n "${LAST_FILE:-}" ]; then
+    LAST_ACTIVITY=$(date -r "$LAST_FILE" -u +"%Y-%m-%dT%H:%M:%SZ" 2>/dev/null || echo "unknown")
+  fi
+fi
+
+echo "pending:$PENDING in_progress:$IN_PROGRESS done:$DONE failed:$FAILED archived:$ARCHIVED last_activity:$LAST_ACTIVITY"

data/.ai-assistance/scripts/capabilities-check.ts

@@ -0,0 +1,104 @@
+#!/usr/bin/env npx ts-node
+/**
+ * capabilities-check.ts
+ * Periodic assumptions review agent.
+ * Uses Claude Haiku (cheap + fast) to verify stale entries in assumptions-log.md.
+ * Updates log with verification results and timestamps.
+ *
+ * Usage:
+ *   npx ts-node .ai-assistance/scripts/capabilities-check.ts
+ *
+ * Requires:
+ *   ANTHROPIC_API_KEY env var
+ *   npm install @anthropic-ai/sdk
+ */
+
+import Anthropic from "@anthropic-ai/sdk";
+import { readFileSync, writeFileSync } from "fs";
+import { join, dirname } from "path";
+
+const STALE_DAYS = 30;
+
+const scriptDir = dirname(process.argv[1]);
+const logPath = join(scriptDir, "../capabilities/assumptions-log.md");
+
+// --- Read log ---
+const log = readFileSync(logPath, "utf8");
+
+// --- Find stale or NEEDS_REVIEW entries ---
+const entryPattern = /### (\d{4}-\d{2}-\d{2}) — (.+?)\nSTATUS: (CONFIRMED|NEEDS_REVIEW|RESOLVED|INVALIDATED)\nLast checked: (\d{4}-\d{2}-\d{2})/g;
+
+const now = new Date();
+const staleEntries: { title: string; date: string; status: string }[] = [];
+
+let match;
+while ((match = entryPattern.exec(log)) !== null) {
+  const [, , title, status, lastChecked] = match;
+  const checkedDate = new Date(lastChecked);
+  const daysSince = (now.getTime() - checkedDate.getTime()) / (1000 * 60 * 60 * 24);
+
+  if (status === "NEEDS_REVIEW" || daysSince > STALE_DAYS) {
+    staleEntries.push({ title, date: lastChecked, status });
+  }
+}
+
+if (staleEntries.length === 0) {
+  console.log("All assumptions current. No review needed.");
+  process.exit(0);
+}
+
+console.log(`Found ${staleEntries.length} stale/flagged assumption(s). Reviewing...`);
+
+// --- Use Haiku to check each ---
+const client = new Anthropic();
+
+async function checkAssumption(title: string): Promise<string> {
+  const message = await client.messages.create({
+    model: "claude-haiku-4-5-20251001",
+    max_tokens: 300,
+    messages: [
+      {
+        role: "user",
+        content: `You are verifying a technical assumption about Claude/Anthropic products.
+Assumption: "${title}"
+Today's date: ${now.toISOString().slice(0, 10)}
+
+Search your knowledge for whether this is still accurate.
+Reply in this format exactly:
+STATUS: CONFIRMED | NEEDS_REVIEW | RESOLVED | INVALIDATED
+NOTES: <one sentence explaining current state>`,
+      },
+    ],
+  });
+
+  const text = message.content[0].type === "text" ? message.content[0].text : "";
+  return text.trim();
+}
+
+// --- Update log entries ---
+let updatedLog = log;
+const todayStr = now.toISOString().slice(0, 10);
+
+for (const entry of staleEntries) {
+  const result = await checkAssumption(entry.title);
+  const statusLine = result.match(/^STATUS: (.+)$/m)?.[1]?.trim() ?? "NEEDS_REVIEW";
+  const notesLine = result.match(/^NOTES: (.+)$/m)?.[1]?.trim() ?? "Auto-check inconclusive";
+
+  console.log(`  [${entry.title}] → ${statusLine}: ${notesLine}`);
+
+  // Update the entry in the log
+  updatedLog = updatedLog.replace(
+    new RegExp(`(### ${entry.date} — ${entry.title}\\nSTATUS:) [A-Z_]+\\n(Last checked:) [0-9-]+`),
+    `$1 ${statusLine}\n$2 ${todayStr}`
+  );
+}
+
+// Append a review run summary
+updatedLog += `\n### ${todayStr} — Automated review run
+STATUS: CONFIRMED
+Last checked: ${todayStr}
+Source: capabilities-check.ts
+Notes: Reviewed ${staleEntries.length} stale entries. See individual entries for results.\n`;
+
+writeFileSync(logPath, updatedLog, "utf8");
+console.log(`Updated assumptions-log.md`);

data/.ai-assistance/scripts/check-outbox.sh

@@ -0,0 +1,43 @@
+#!/bin/bash
+# check-outbox.sh
+# Check if Code has responded to a specific bridge task.
+# Used by CoWork to confirm handoff completion without reading raw files.
+#
+# Usage:
+#   bash .ai-assistance/scripts/check-outbox.sh oscar-a3f2b1c-list-open-mrs.md
+#
+# Output:
+#   DONE | <first 120 chars of result>
+#   PENDING | no response yet
+#   FAILED | <notes>
+#   ERROR | <reason>
+
+set -euo pipefail
+
+TASK_FILE="${1:-}"
+if [ -z "$TASK_FILE" ]; then
+  echo "ERROR | usage: check-outbox.sh <task-filename>"
+  exit 1
+fi
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+OUTBOX_DIR="$SCRIPT_DIR/../bridge/outbox"
+ARCHIVE_DIR="$SCRIPT_DIR/../bridge/archive"
+OUTBOX_PATH="$OUTBOX_DIR/$TASK_FILE"
+ARCHIVE_OUTBOX_PATH="$ARCHIVE_DIR/outbox-$TASK_FILE"
+
+# Check outbox first, then archive
+if [ -f "$OUTBOX_PATH" ]; then
+  TARGET="$OUTBOX_PATH"
+elif [ -f "$ARCHIVE_OUTBOX_PATH" ]; then
+  TARGET="$ARCHIVE_OUTBOX_PATH"
+else
+  echo "PENDING | no response yet"
+  exit 0
+fi
+
+STATUS=$(grep "^STATUS:" "$TARGET" | head -1 | awk '{print $2}')
+RESULT=$(awk '/^## Result/{found=1; next} found && /^## /{exit} found{print}' "$TARGET" \
+  | head -3 | tr '\n' ' ' | cut -c1-120)
+
+echo "$STATUS | $RESULT"

data/.ai-assistance/scripts/dep_graph.rb

@@ -0,0 +1,91 @@
+# .ai-assistance/scripts/dep_graph.rb
+#
+# Generates a JSON structural map of the gem's class/module hierarchy and
+# inter-file relationships. No gem dependencies — Ruby stdlib only.
+#
+# Usage (via rake dep_graph):
+#   DepGraph.run(lib_dir: 'lib', output_path: '.ai-assistance/code/dep-graph.json')
+#
+# Output per file:
+#   defines  — fully-qualified module/class names defined in the file
+#   requires — require_relative paths
+#   includes — include/extend/prepend targets
+
+require 'json'
+
+module DepGraph
+  module_function
+
+  def run(lib_dir: 'lib', output_path: '.ai-assistance/code/dep-graph.json')
+    files = Dir.glob(File.join(lib_dir, '**', '*.rb')).sort
+    result = files.each_with_object({}) do |file, map|
+      entry = analyse(file)
+      map[file] = entry unless entry.values.all?(&:empty?)
+    end
+
+    File.write(output_path, JSON.pretty_generate(result))
+    result
+  end
+
+  def analyse(file)
+    src    = File.read(file, encoding: 'utf-8')
+    lines  = src.lines
+
+    defines  = extract_defines(lines)
+    requires = extract_requires(lines)
+    includes = extract_includes(lines)
+
+    { 'defines' => defines, 'requires' => requires, 'includes' => includes }
+  end
+
+  # ---------------------------------------------------------------------------
+  # Extract fully-qualified module/class names by tracking a nesting stack.
+  # Handles:
+  #   module Foo; module Bar   (inline)
+  #   class Baz::Qux           (compact namespace)
+  #   end                      (pops one level per bare `end`)
+  # ---------------------------------------------------------------------------
+  def extract_defines(lines)
+    stack   = []
+    defines = []
+
+    lines.each do |line|
+      stripped = line.strip
+
+      # module Foo or class Bar (or class Bar < Baz)
+      if (m = stripped.match(/\A(module|class)\s+([\w:]+)/))
+        parts    = m[2].split('::')
+        new_name = (stack + parts).join('::')
+        defines << new_name
+        stack.push(*parts)
+
+      # bare `end` — pop one stack level
+      elsif stripped == 'end'
+        stack.pop unless stack.empty?
+      end
+    end
+
+    defines.uniq
+  end
+
+  # ---------------------------------------------------------------------------
+  # Extract require_relative paths (strips quotes and .rb suffix).
+  # ---------------------------------------------------------------------------
+  def extract_requires(lines)
+    lines.filter_map do |line|
+      m = line.strip.match(/\Arequire_relative\s+['"](.+?)['"]/)
+      m && m[1].delete_suffix('.rb')
+    end.uniq
+  end
+
+  # ---------------------------------------------------------------------------
+  # Extract include / extend / prepend targets (module names only).
+  # Ignores method calls with arguments beyond the module name.
+  # ---------------------------------------------------------------------------
+  def extract_includes(lines)
+    lines.filter_map do |line|
+      m = line.strip.match(/\A(?:include|extend|prepend)\s+([\w:]+)/)
+      m && m[1]
+    end.uniq
+  end
+end

data/.ai-assistance/scripts/lock-acquire.sh

@@ -0,0 +1,103 @@
+#!/bin/bash
+# lock-acquire.sh
+# Atomically acquire the bridge LOCK file.
+#
+# Atomicity: writes content to a temp file, then hard-links it to LOCK.
+# Hard-link creation is atomic on POSIX filesystems (ext4, APFS, NTFS via Git Bash).
+# Only one of two concurrent callers can win the ln race — the loser gets exit 1.
+# Falls back to bash noclobber if hard links are unavailable (cross-filesystem edge case).
+#
+# Usage:
+#   bash lock-acquire.sh \
+#     --agent code \
+#     --user oscar \
+#     --intent "Implementing Phase D mutations" \
+#     [--expiry-minutes 60]      # default: 60
+#     [--lock-file /custom/path] # default: bridge/LOCK
+#
+# Exit codes:
+#   0  — lock acquired; JSON: {"acquired":true,"lock_file":"..."}
+#   1  — lock already held or contention; JSON: {"acquired":false,"reason":"...","held_by":"..."}
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+LOCK_FILE="${LOCK_FILE:-$SCRIPT_DIR/../bridge/LOCK}"
+EXPIRY_MINUTES=60
+AGENT=""
+USER_SLUG=""
+INTENT=""
+
+# --- Parse args ---
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --agent)          AGENT="$2";          shift 2 ;;
+    --user)           USER_SLUG="$2";      shift 2 ;;
+    --intent)         INTENT="$2";         shift 2 ;;
+    --expiry-minutes) EXPIRY_MINUTES="$2"; shift 2 ;;
+    --lock-file)      LOCK_FILE="$2";      shift 2 ;;
+    *) echo "{\"acquired\":false,\"reason\":\"unknown argument: $1\"}"; exit 1 ;;
+  esac
+done
+
+if [ -z "$AGENT" ] || [ -z "$USER_SLUG" ] || [ -z "$INTENT" ]; then
+  echo '{"acquired":false,"reason":"missing required argument (--agent, --user, --intent)"}'
+  exit 1
+fi
+
+# --- Check for existing lock ---
+if [ -f "$LOCK_FILE" ]; then
+  # Determine age via stat (GNU stat on Linux/Git Bash: -c %Y; BSD/macOS: -f %m)
+  mtime=$(stat -c %Y "$LOCK_FILE" 2>/dev/null || stat -f %m "$LOCK_FILE" 2>/dev/null || echo 0)
+  now=$(date +%s)
+  age=$(( now - mtime ))
+  max_age=$(( EXPIRY_MINUTES * 60 ))
+
+  if [ "$age" -lt "$max_age" ]; then
+    # Lock is active — report who holds it
+    held_agent=$(grep "^AGENT:" "$LOCK_FILE" 2>/dev/null | sed 's/^AGENT: //' || echo "unknown")
+    held_user=$(grep "^USER:"  "$LOCK_FILE" 2>/dev/null | sed 's/^USER: //'  || echo "unknown")
+    held_intent=$(grep "^INTENT:" "$LOCK_FILE" 2>/dev/null | sed 's/^INTENT: //' || echo "")
+    echo "{\"acquired\":false,\"reason\":\"locked\",\"held_by\":\"$held_agent/$held_user\",\"intent\":\"$held_intent\",\"age_seconds\":$age}"
+    exit 1
+  fi
+  # Lock is stale — fall through and overwrite it
+  rm -f "$LOCK_FILE"
+fi
+
+# --- Build lock content ---
+NOW=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+# Compute expiry — GNU date: -d "+N minutes"; BSD/macOS: -v +NM
+EXPIRES=$(date -u -d "+${EXPIRY_MINUTES} minutes" +"%Y-%m-%dT%H:%M:%SZ" 2>/dev/null \
+       || date -u -v +${EXPIRY_MINUTES}M           +"%Y-%m-%dT%H:%M:%SZ" 2>/dev/null \
+       || echo "unknown")
+
+CONTENT="AGENT: ${AGENT}
+USER: ${USER_SLUG}
+ACQUIRED: ${NOW}
+EXPIRES: ${EXPIRES}
+INTENT: ${INTENT}"
+
+# --- Atomic acquisition: temp file + hard link ---
+LOCK_DIR="$(dirname "$LOCK_FILE")"
+TMPFILE=$(mktemp "$LOCK_DIR/.lock-tmp.XXXXXX")
+printf '%s\n' "$CONTENT" > "$TMPFILE"
+
+if ln "$TMPFILE" "$LOCK_FILE" 2>/dev/null; then
+  # Hard link succeeded — we own the lock
+  rm -f "$TMPFILE"
+  echo "{\"acquired\":true,\"lock_file\":\"$LOCK_FILE\",\"expires\":\"$EXPIRES\"}"
+  exit 0
+fi
+
+# Hard link failed (LOCK re-appeared in the race window, or cross-fs)
+rm -f "$TMPFILE"
+
+# Fallback: bash noclobber (not fully atomic, but good enough for single-user scenarios)
+if ( set -o noclobber; printf '%s\n' "$CONTENT" > "$LOCK_FILE" ) 2>/dev/null; then
+  echo "{\"acquired\":true,\"lock_file\":\"$LOCK_FILE\",\"expires\":\"$EXPIRES\",\"method\":\"noclobber\"}"
+  exit 0
+fi
+
+echo "{\"acquired\":false,\"reason\":\"contention\"}"
+exit 1

data/.ai-assistance/scripts/lock-multi.sh

@@ -0,0 +1,124 @@
+#!/usr/bin/env bash
+# lock-multi.sh
+# Acquire the bridge LOCK across multiple repos atomically.
+# Locks repos in order; rolls back already-acquired locks on failure.
+# Checks queue for higher-priority waiters before acquiring.
+#
+# Cross-repo lock timeout policy:
+#   --expiry-minutes sets a hard LOCK expiry (default: 60).
+#   --estimated-minutes sets the ESTIMATED_RELEASE field in each LOCK —
+#   a human-readable "I expect to be done in N minutes" hint for other agents.
+#   If the acquiring agent finishes early, it should release all locks immediately.
+#   If it crashes, lock-acquire.sh on the next attempt will detect stale locks
+#   (mtime > expiry) and overwrite them automatically.
+#
+# Usage:
+#   bash lock-multi.sh \
+#     --agent code \
+#     --user oscar \
+#     --intent "Cross-repo refactor" \
+#     --repo /path/to/repo1 \
+#     --repo /path/to/repo2 \
+#     [--expiry-minutes 60]        # hard timeout (default: 60)
+#     [--estimated-minutes 20]     # expected work duration (default: = expiry)
+#
+# Exit 0: all locks acquired. Prints JSON with acquired lock paths.
+# Exit 1: one or more locks could not be acquired. All acquired locks rolled back.
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+LOCK_SCRIPT="$SCRIPT_DIR/lock-acquire.sh"
+
+AGENT="" USER_SLUG="" INTENT="" EXPIRY_MINUTES=60 ESTIMATED_MINUTES=""
+REPOS=()
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --agent)              AGENT="$2";              shift 2 ;;
+    --user)               USER_SLUG="$2";          shift 2 ;;
+    --intent)             INTENT="$2";             shift 2 ;;
+    --repo)               REPOS+=("$2");           shift 2 ;;
+    --expiry-minutes)     EXPIRY_MINUTES="$2";     shift 2 ;;
+    --estimated-minutes)  ESTIMATED_MINUTES="$2";  shift 2 ;;
+    *) echo "{\"acquired\":false,\"reason\":\"unknown argument: $1\"}"; exit 1 ;;
+  esac
+done
+
+[[ -z "$AGENT" || -z "$USER_SLUG" || -z "$INTENT" ]] && {
+  echo '{"acquired":false,"reason":"missing --agent, --user, or --intent"}'; exit 1; }
+[[ ${#REPOS[@]} -eq 0 ]] && REPOS=("$(pwd)")
+
+# Default estimated = expiry (conservative)
+[[ -z "$ESTIMATED_MINUTES" ]] && ESTIMATED_MINUTES="$EXPIRY_MINUTES"
+
+NOW=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+ESTIMATED_RELEASE=$(date -u -d "+${ESTIMATED_MINUTES} minutes" +"%Y-%m-%dT%H:%M:%SZ" 2>/dev/null \
+                 || date -u -v +${ESTIMATED_MINUTES}M            +"%Y-%m-%dT%H:%M:%SZ" 2>/dev/null \
+                 || echo "unknown")
+
+ACQUIRED=()
+FAILED=""
+QUEUE_NOTICES=()
+
+for repo in "${REPOS[@]}"; do
+  LOCK_FILE="$repo/.ai-assistance/bridge/LOCK"
+
+  # ── Stale lock enforcement: explicitly check mtime before delegating ──────
+  # lock-acquire.sh handles this too, but we do it here for cross-repo clarity.
+  if [[ -f "$LOCK_FILE" ]]; then
+    mtime=$(stat -c %Y "$LOCK_FILE" 2>/dev/null || stat -f %m "$LOCK_FILE" 2>/dev/null || echo 0)
+    age=$(( $(date +%s) - mtime ))
+    max_age=$(( EXPIRY_MINUTES * 60 ))
+    if [[ "$age" -ge "$max_age" ]]; then
+      rm -f "$LOCK_FILE"
+      echo "  [lock-multi] stale lock removed at $repo (age: ${age}s > ${max_age}s)" >&2
+    fi
+  fi
+
+  # ── Check queue for higher-priority waiters ───────────────────────────────
+  QUEUE_DIR="$repo/.ai-assistance/bridge/queue"
+  if [[ -d "$QUEUE_DIR" ]]; then
+    for qf in "$QUEUE_DIR"/1-critical-*.json "$QUEUE_DIR"/2-high-*.json; do
+      [[ -f "$qf" ]] || continue
+      pri=$(python3 -c "import json,sys; d=json.load(open(sys.argv[1])); print(d.get('priority','?'))" "$qf" 2>/dev/null || echo "?")
+      agt=$(python3 -c "import json,sys; d=json.load(open(sys.argv[1])); print(d.get('agent','?'))" "$qf" 2>/dev/null || echo "?")
+      intent_q=$(python3 -c "import json,sys; d=json.load(open(sys.argv[1])); print(d.get('intent','?'))" "$qf" 2>/dev/null || echo "?")
+      QUEUE_NOTICES+=("repo=$(basename "$repo") priority=$pri agent=$agt intent=\"$intent_q\"")
+    done
+  fi
+
+  # ── Acquire lock via lock-acquire.sh ─────────────────────────────────────
+  # Include ESTIMATED_RELEASE in the intent so it appears in the LOCK file text
+  FULL_INTENT="${INTENT} | estimated_release:${ESTIMATED_RELEASE} | multi-repo:$(printf '%s,' "${REPOS[@]}" | sed 's/,$//')"
+
+  result=$(bash "$LOCK_SCRIPT" \
+    --agent "$AGENT" --user "$USER_SLUG" \
+    --intent "$FULL_INTENT" \
+    --expiry-minutes "$EXPIRY_MINUTES" \
+    --lock-file "$LOCK_FILE" 2>/dev/null || true)
+
+  ok=$(echo "$result" | python3 -c "import json,sys; d=json.load(sys.stdin); print('yes' if d.get('acquired') else 'no')" 2>/dev/null || echo "no")
+
+  if [[ "$ok" == "yes" ]]; then
+    ACQUIRED+=("$LOCK_FILE")
+  else
+    FAILED="$repo — $(echo "$result" | python3 -c "import json,sys; d=json.load(sys.stdin); print(d.get('reason','unknown'))" 2>/dev/null || echo 'unknown')"
+    break
+  fi
+done
+
+# ── Rollback all acquired locks if any failed ─────────────────────────────
+if [[ -n "$FAILED" ]]; then
+  for lf in "${ACQUIRED[@]}"; do rm -f "$lf"; done
+  echo "{\"acquired\":false,\"reason\":\"$FAILED\",\"rolled_back\":${#ACQUIRED[@]}}"
+  exit 1
+fi
+
+# ── Output ────────────────────────────────────────────────────────────────
+FILES_JSON=$(printf '"%s",' "${ACQUIRED[@]}" | sed 's/,$//')
+NOTICES_JSON=$(printf '"%s",' "${QUEUE_NOTICES[@]:-}" | sed 's/,$//')
+echo "{\"acquired\":true,\"locks\":[$FILES_JSON],\"estimated_release\":\"$ESTIMATED_RELEASE\",\"expiry_minutes\":$EXPIRY_MINUTES,\"queue_notices\":[$NOTICES_JSON]}"
+echo "" >&2
+[[ ${#QUEUE_NOTICES[@]} -gt 0 ]] && \
+  echo "  [lock-multi] NOTE: higher-priority waiters in queue — wrap up within ${ESTIMATED_MINUTES} min" >&2