ecoportal-api-graphql 1.3.13 → 1.3.16

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

@@ -1,44 +0,0 @@
-#!/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

@@ -1,104 +0,0 @@
-#!/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

@@ -1,43 +0,0 @@
-#!/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

@@ -1,91 +0,0 @@
-# .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

@@ -1,103 +0,0 @@
-#!/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

@@ -1,124 +0,0 @@
-#!/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

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

@@ -1,94 +0,0 @@
-#!/usr/bin/env bash
-# lock-queue.sh
-# Drop a priority turn-request into the bridge queue of one or more repos.
-# Used when a lock is held and this agent wants to wait with declared priority.
-#
-# Usage:
-#   bash lock-queue.sh \
-#     --agent cowork \
-#     --user oscar \
-#     --intent "Review auth changes" \
-#     --priority high \
-#     --target-project ep-claude-aws-platform \
-#     [--repo /path/to/repo1 --repo /path/to/repo2 ...] \
-#     [--expiry-minutes 90]
-#
-# Writes: .ai-assistance/bridge/queue/<priority>-<ts>-<id>.json in each repo
-# Exit 0: request(s) queued. Prints JSON with queue file paths.
-
-set -euo pipefail
-
-AGENT="" USER_SLUG="" INTENT="" PRIORITY="medium" TARGET_PROJECT=""
-EXPIRY_MINUTES=90 ESTIMATED_WAIT_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 ;;
-    --priority)             PRIORITY="$2";             shift 2 ;;
-    --target-project)       TARGET_PROJECT="$2";       shift 2 ;;
-    --estimated-wait)       ESTIMATED_WAIT_MINUTES="$2"; shift 2 ;;
-    --repo)            REPOS+=("$2");       shift 2 ;;
-    --expiry-minutes)  EXPIRY_MINUTES="$2"; shift 2 ;;
-    *) echo "{\"queued\":false,\"reason\":\"unknown argument: $1\"}"; exit 1 ;;
-  esac
-done
-
-[[ -z "$AGENT" || -z "$USER_SLUG" || -z "$INTENT" ]] && {
-  echo '{"queued":false,"reason":"missing --agent, --user, or --intent"}'; exit 1; }
-
-# Default: current repo
-[[ ${#REPOS[@]} -eq 0 ]] && REPOS=("$(pwd)")
-
-NOW=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
-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")
-REQUEST_ID="req-$(date +%s)-$$"
-
-# Priority sort prefix: 1=critical 2=high 3=medium 4=low
-case "$PRIORITY" in
-  critical) PFX="1" ;; high) PFX="2" ;; medium) PFX="3" ;; low) PFX="4" ;; *) PFX="3" ;;
-esac
-
-QUEUED_FILES=()
-
-# estimated_wait: read from the current LOCK file if present (it may contain estimated_release)
-get_estimated_release() {
-  local lock="$1/.ai-assistance/bridge/LOCK"
-  [[ -f "$lock" ]] || { echo "unknown"; return; }
-  grep "estimated_release:" "$lock" 2>/dev/null | sed 's/.*estimated_release://' | tr -d ' ' | head -1 || echo "unknown"
-}
-
-for repo in "${REPOS[@]}"; do
-  QUEUE_DIR="$repo/.ai-assistance/bridge/queue"
-  [[ -d "$QUEUE_DIR" ]] || mkdir -p "$QUEUE_DIR"
-  QFILE="$QUEUE_DIR/${PFX}-${PRIORITY}-$(date +%s%3N)-${REQUEST_ID}.json"
-
-  # Read current lock's estimated release so queue entry shows the expected wait
-  LOCK_ESTIMATED_RELEASE=$(get_estimated_release "$repo")
-  EFFECTIVE_WAIT="${ESTIMATED_WAIT_MINUTES:-unknown}"
-
-  cat > "$QFILE" << JSON
-{
-  "request_id": "$REQUEST_ID",
-  "agent": "$AGENT",
-  "user": "$USER_SLUG",
-  "intent": "$INTENT",
-  "priority": "$PRIORITY",
-  "target_project": "$TARGET_PROJECT",
-  "repo": "$repo",
-  "requested_at": "$NOW",
-  "expires_at": "$EXPIRES",
-  "estimated_wait_minutes": "$EFFECTIVE_WAIT",
-  "current_lock_estimated_release": "$LOCK_ESTIMATED_RELEASE"
-}
-JSON
-  QUEUED_FILES+=("$QFILE")
-done
-
-# Report
-FILES_JSON=$(printf '"%s",' "${QUEUED_FILES[@]}" | sed 's/,$//')
-echo "{\"queued\":true,\"request_id\":\"$REQUEST_ID\",\"priority\":\"$PRIORITY\",\"files\":[$FILES_JSON]}"