@indigoai-us/hq-cli 5.314.0 → 5.316.0

package/assets/scaffold/core/scripts/repo-run-registry.sh

@@ -0,0 +1,408 @@
+#!/bin/bash
+# repo-run-registry.sh — CLI for cross-session repo-level run coordination
+#
+# Manages workspace/orchestrator/active-runs.json: a global registry of
+# long-running Claude sessions that currently hold a repo (scope=repo) or
+# a specific worktree (scope=worktree:<path>). Other sessions consult this
+# registry at SessionStart and before Edit/Write/dangerous Bash to avoid
+# concurrent edit conflicts.
+#
+# See plan: ~/.claude/plans/structured-stargazing-candy.md
+# Policy: core/policies/repo-run-coordination.md
+#
+# Subcommands:
+#   register  --run-id X --pid N --session-id S --command C --project P --repo R --scope SC [--host H]
+#   deregister --run-id X
+#   heartbeat --run-id X
+#   list
+#   check --target PATH [--pid N] [--session-id S]
+#   clean-stale
+#   owner-of --path PATH
+#
+# Exit codes:
+#   0 = ok / not blocked
+#   2 = blocked by foreign owner (check only)
+#   1 = usage / internal error
+
+set -euo pipefail
+
+HQ_ROOT="${HQ_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)}"
+# shellcheck source=core/scripts/lib/portable.sh
+. "$HQ_ROOT/core/scripts/lib/portable.sh"
+REG_DIR="$HQ_ROOT/workspace/orchestrator"
+REG_FILE="$REG_DIR/active-runs.json"
+LOCK_DIR="$REG_FILE.lock"
+# Resolve the orchestrator settings file. personal/settings is read DIRECTLY now
+# (the reindex symlink mirror into core/settings is retired). orchestrator.yaml
+# ships as a core default; unlike the list-shaped overlays (policies/workers/
+# knowledge, where core + personal BOTH surface), this is a singleton config
+# file — so a personal copy, when present, overrides the shipped default.
+ORCH_YAML="$HQ_ROOT/core/settings/orchestrator.yaml"
+if [[ -f "$HQ_ROOT/personal/settings/orchestrator.yaml" ]]; then
+  ORCH_YAML="$HQ_ROOT/personal/settings/orchestrator.yaml"
+fi
+
+# ---------- helpers ----------
+
+_log() { echo "[repo-run-registry] $*" >&2; }
+_die() { echo "ERROR: $*" >&2; exit 1; }
+
+_iso_now() { date -u +"%Y-%m-%dT%H:%M:%SZ"; }
+
+# ISO8601 (UTC, trailing Z) → epoch seconds. BSD date first, then GNU date.
+# A BSD-only parse returned 0 on Linux, so _prune_stale treated every live
+# run as stale and deleted it before any check could block on it.
+_iso_to_epoch() {
+  local iso="$1"
+  date -u -j -f "%Y-%m-%dT%H:%M:%SZ" "$iso" +%s 2>/dev/null \
+    || date -u -d "$iso" +%s 2>/dev/null \
+    || echo 0
+}
+
+_hostname() { hostname -s 2>/dev/null || echo "unknown"; }
+
+_abs_path() {
+  local p="$1"
+  if [[ "$p" = /* ]]; then
+    echo "$p"
+  else
+    (cd "$(dirname "$p")" 2>/dev/null && echo "$(pwd)/$(basename "$p")") || echo "$p"
+  fi
+}
+
+_ensure_reg() {
+  mkdir -p "$REG_DIR"
+  if [[ ! -f "$REG_FILE" ]]; then
+    echo '{"version":1,"runs":[]}' > "$REG_FILE"
+  fi
+}
+
+# Atomic mutex via mkdir — single-machine only
+_lock() { _try_lock || _die "registry lock timeout"; }
+
+# Returns 1 instead of exiting when the lock stays busy (~5s).
+_try_lock() {
+  local tries=0
+  local max=50
+  # register takes the lock before _ensure_reg; without its parent the mkdir
+  # below can never succeed and the first register on a fresh install timed out.
+  mkdir -p "$REG_DIR" 2>/dev/null || true
+  while ! mkdir "$LOCK_DIR" 2>/dev/null; do
+    tries=$((tries + 1))
+    if [[ $tries -ge $max ]]; then
+      # stale lock fallback: remove if older than 60s
+      if [[ -d "$LOCK_DIR" ]]; then
+        local age mtime
+        mtime="$(portable_stat_mtime "$LOCK_DIR" 2>/dev/null || echo 0)"
+        age=$(( $(date +%s) - mtime ))
+        if [[ $age -gt 60 ]]; then
+          rm -rf "$LOCK_DIR" 2>/dev/null || true
+          continue
+        fi
+      fi
+      return 1
+    fi
+    sleep 0.1
+  done
+}
+_unlock() { rm -rf "$LOCK_DIR" 2>/dev/null || true; }
+
+# list, owner-of and check prune too. Hold the lock so a reader cannot write an
+# older snapshot over a concurrent register or heartbeat. If the lock stays
+# busy, skip the prune and answer from the file as it is.
+_prune_stale_locked() {
+  _try_lock || return 0
+  trap '_unlock' EXIT
+  _prune_stale >/dev/null 2>&1 || true
+  _unlock
+  trap - EXIT
+}
+
+_is_pid_alive() {
+  local pid="$1"
+  [[ -z "$pid" || "$pid" == "null" ]] && return 1
+  kill -0 "$pid" 2>/dev/null
+}
+
+_stale_minutes() {
+  if [[ -f "$ORCH_YAML" ]] && command -v yq >/dev/null 2>&1; then
+    local v
+    v=$(yq eval '.repo_coordination.stale_heartbeat_minutes // 15' "$ORCH_YAML" 2>/dev/null)
+    [[ -n "$v" && "$v" != "null" ]] && { echo "$v"; return; }
+  fi
+  echo 15
+}
+
+# Given a target filesystem path, walk up to find the nearest ancestor that
+# is either a git repo root OR a HQ orchestrator-known repo path. Emits the
+# absolute path of the owning repo (or empty string if none).
+_find_owning_repo() {
+  local target
+  target=$(_abs_path "$1")
+  [[ -z "$target" ]] && return
+  # If target doesn't exist, walk up to an existing ancestor first
+  while [[ -n "$target" && ! -e "$target" ]]; do
+    local parent
+    parent=$(dirname "$target")
+    [[ "$parent" == "$target" ]] && return
+    target="$parent"
+  done
+  # Now walk up looking for .git
+  local dir="$target"
+  [[ -f "$dir" ]] && dir=$(dirname "$dir")
+  while [[ "$dir" != "/" && -n "$dir" ]]; do
+    if [[ -e "$dir/.git" ]]; then
+      echo "$dir"
+      return
+    fi
+    dir=$(dirname "$dir")
+  done
+  echo ""
+}
+
+# Prune stale entries: dead PID OR heartbeat older than stale_minutes.
+# Emits the number of pruned entries on stderr.
+_prune_stale() {
+  _ensure_reg
+  local stale_min
+  stale_min=$(_stale_minutes)
+  local now_epoch
+  now_epoch=$(date +%s)
+  local cutoff=$((now_epoch - stale_min * 60))
+
+  # Build a jq filter that keeps only entries with fresh heartbeat; then
+  # separately filter dead PIDs in bash.
+  local tmp="$REG_FILE.tmp.$$"
+  local kept='[]'
+  local runs
+  runs=$(jq -c '.runs[]' "$REG_FILE" 2>/dev/null || true)
+  local pruned=0
+  if [[ -n "$runs" ]]; then
+    while IFS= read -r entry; do
+      [[ -z "$entry" ]] && continue
+      local pid hb_iso hb_epoch
+      pid=$(echo "$entry" | jq -r '.pid // empty')
+      hb_iso=$(echo "$entry" | jq -r '.heartbeat_at // .started_at // empty')
+      hb_epoch=$(_iso_to_epoch "$hb_iso")
+      if ! _is_pid_alive "$pid"; then
+        pruned=$((pruned + 1))
+        continue
+      fi
+      if [[ $hb_epoch -lt $cutoff ]]; then
+        pruned=$((pruned + 1))
+        continue
+      fi
+      kept=$(echo "$kept" | jq --argjson e "$entry" '. + [$e]')
+    done <<< "$runs"
+  fi
+  jq --argjson runs "$kept" '.runs = $runs' "$REG_FILE" > "$tmp"
+  mv "$tmp" "$REG_FILE"
+  [[ $pruned -gt 0 ]] && _log "pruned $pruned stale entries"
+  return 0
+}
+
+# ---------- subcommands ----------
+
+_cmd_register() {
+  local run_id="" pid="" session_id="" command="" project="" repo="" scope="" host=""
+  while [[ $# -gt 0 ]]; do
+    case "$1" in
+      --run-id) run_id="$2"; shift 2 ;;
+      --pid) pid="$2"; shift 2 ;;
+      --session-id) session_id="$2"; shift 2 ;;
+      --command) command="$2"; shift 2 ;;
+      --project) project="$2"; shift 2 ;;
+      --repo) repo="$2"; shift 2 ;;
+      --scope) scope="$2"; shift 2 ;;
+      --host) host="$2"; shift 2 ;;
+      *) shift ;;
+    esac
+  done
+  [[ -z "$pid" || -z "$command" || -z "$repo" || -z "$scope" ]] && \
+    _die "register requires --pid --command --repo --scope"
+  repo=$(_abs_path "$repo")
+  [[ -z "$run_id" ]] && run_id="$(echo "$command" | tr '/' '-')-$(date +%s)-${project:-none}-$pid"
+  [[ -z "$host" ]] && host=$(_hostname)
+
+  _lock
+  trap '_unlock' EXIT
+  _ensure_reg
+  _prune_stale
+
+  local now
+  now=$(_iso_now)
+  local tmp="$REG_FILE.tmp.$$"
+  jq --arg run_id "$run_id" \
+     --arg pid "$pid" \
+     --arg session_id "$session_id" \
+     --arg command "$command" \
+     --arg project "$project" \
+     --arg repo "$repo" \
+     --arg scope "$scope" \
+     --arg host "$host" \
+     --arg now "$now" \
+    '.runs |= map(select(.run_id != $run_id)) |
+     .runs += [{
+       run_id: $run_id,
+       pid: ($pid | tonumber),
+       session_id: $session_id,
+       command: $command,
+       project: $project,
+       repo_path: $repo,
+       scope: $scope,
+       host: $host,
+       started_at: $now,
+       heartbeat_at: $now
+     }]' "$REG_FILE" > "$tmp"
+  mv "$tmp" "$REG_FILE"
+  _unlock
+  trap - EXIT
+  echo "$run_id"
+}
+
+_cmd_deregister() {
+  local run_id=""
+  while [[ $# -gt 0 ]]; do
+    case "$1" in
+      --run-id) run_id="$2"; shift 2 ;;
+      *) shift ;;
+    esac
+  done
+  [[ -z "$run_id" ]] && _die "deregister requires --run-id"
+  _lock
+  trap '_unlock' EXIT
+  _ensure_reg
+  local tmp="$REG_FILE.tmp.$$"
+  jq --arg run_id "$run_id" '.runs |= map(select(.run_id != $run_id))' "$REG_FILE" > "$tmp"
+  mv "$tmp" "$REG_FILE"
+  _unlock
+  trap - EXIT
+}
+
+_cmd_heartbeat() {
+  local run_id=""
+  while [[ $# -gt 0 ]]; do
+    case "$1" in
+      --run-id) run_id="$2"; shift 2 ;;
+      *) shift ;;
+    esac
+  done
+  [[ -z "$run_id" ]] && _die "heartbeat requires --run-id"
+  _lock
+  trap '_unlock' EXIT
+  _ensure_reg
+  local now
+  now=$(_iso_now)
+  local tmp="$REG_FILE.tmp.$$"
+  jq --arg run_id "$run_id" --arg now "$now" \
+    '.runs |= map(if .run_id == $run_id then .heartbeat_at = $now else . end)' \
+    "$REG_FILE" > "$tmp"
+  mv "$tmp" "$REG_FILE"
+  _unlock
+  trap - EXIT
+}
+
+_cmd_list() {
+  _ensure_reg
+  _prune_stale_locked
+  jq '.runs' "$REG_FILE"
+}
+
+_cmd_clean_stale() {
+  _lock
+  trap '_unlock' EXIT
+  _prune_stale
+  _unlock
+  trap - EXIT
+}
+
+_cmd_owner_of() {
+  local path=""
+  while [[ $# -gt 0 ]]; do
+    case "$1" in
+      --path) path="$2"; shift 2 ;;
+      *) shift ;;
+    esac
+  done
+  [[ -z "$path" ]] && _die "owner-of requires --path"
+  local repo
+  repo=$(_find_owning_repo "$path")
+  [[ -z "$repo" ]] && { echo ""; return; }
+  _ensure_reg
+  _prune_stale_locked
+  jq --arg repo "$repo" --arg target "$(_abs_path "$path")" \
+    '[.runs[] | select(
+       (.scope == "repo" and .repo_path == $repo)
+       or (.scope | startswith("worktree:")) and
+          ($target | startswith(.scope | sub("^worktree:"; "")))
+     )]' "$REG_FILE"
+}
+
+# Check if a target path is owned by a foreign run.
+# Exit 0 = clear / self-owned / no owner; exit 2 = blocked by foreign owner.
+_cmd_check() {
+  local target="" my_pid="" my_session=""
+  while [[ $# -gt 0 ]]; do
+    case "$1" in
+      --target) target="$2"; shift 2 ;;
+      --pid) my_pid="$2"; shift 2 ;;
+      --session-id) my_session="$2"; shift 2 ;;
+      *) shift ;;
+    esac
+  done
+  [[ -z "$target" ]] && _die "check requires --target"
+
+  _ensure_reg
+  _prune_stale_locked
+
+  local abs_target
+  abs_target=$(_abs_path "$target")
+  local repo
+  repo=$(_find_owning_repo "$abs_target")
+  [[ -z "$repo" ]] && return 0
+
+  # Collect foreign entries covering this target
+  local matches
+  matches=$(jq -c --arg repo "$repo" \
+                  --arg target "$abs_target" \
+                  --arg mypid "${my_pid:-0}" \
+                  --arg mysid "${my_session:-__none__}" \
+    '[.runs[] | select(
+       ((.scope == "repo" and .repo_path == $repo)
+         or ((.scope | startswith("worktree:")) and
+             ($target | startswith(.scope | sub("^worktree:"; "")))))
+       and ((.pid | tostring) != $mypid)
+       and (.session_id != $mysid)
+     )]' "$REG_FILE" 2>/dev/null || echo '[]')
+
+  local n
+  n=$(echo "$matches" | jq 'length')
+  if [[ "${n:-0}" -eq 0 ]]; then
+    return 0
+  fi
+
+  # Emit one summary line per owner to stderr for the calling hook
+  echo "$matches" | jq -r '.[] |
+    "run_id=\(.run_id) pid=\(.pid) command=\(.command) project=\(.project) scope=\(.scope) repo=\(.repo_path) started=\(.started_at) heartbeat=\(.heartbeat_at)"' >&2
+  return 2
+}
+
+# ---------- dispatch ----------
+
+main() {
+  local sub="${1:-}"
+  [[ -z "$sub" ]] && _die "usage: repo-run-registry.sh <subcommand> [args...]"
+  shift
+  case "$sub" in
+    register) _cmd_register "$@" ;;
+    deregister) _cmd_deregister "$@" ;;
+    heartbeat) _cmd_heartbeat "$@" ;;
+    list) _cmd_list "$@" ;;
+    check) _cmd_check "$@" ;;
+    clean-stale) _cmd_clean_stale "$@" ;;
+    owner-of) _cmd_owner_of "$@" ;;
+    *) _die "unknown subcommand: $sub" ;;
+  esac
+}
+
+main "$@"

package/assets/scaffold/core/scripts/resolve-company.sh

@@ -0,0 +1,199 @@
+#!/usr/bin/env bash
+# hq-core: public
+# resolve-company.sh — resolve the active company for skills and routing.
+#
+# Resolution order (first hit wins): explicit manifest slug in the prompt,
+# session company_slug, enabled device default, then none. Prompt matching is
+# whole-token only; free text never guesses a company.
+#
+# Output: {"company":"<slug>","source":"prompt|session|device_default|none"}
+# Always exits 0 and never writes state.
+
+set -uo pipefail
+
+ROOT=""
+PROMPT=""
+HAVE_PROMPT=0
+
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --root) ROOT="${2:-}"; shift 2 || shift ;;
+    --prompt) PROMPT="${2:-}"; HAVE_PROMPT=1; shift 2 || shift ;;
+    --help|-h)
+      sed -n '2,14p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'
+      exit 0
+      ;;
+    *) shift ;;
+  esac
+done
+
+if [ "$HAVE_PROMPT" -eq 0 ] && [ ! -t 0 ]; then
+  PROMPT="$(cat 2>/dev/null || true)"
+fi
+: "${PROMPT:=}"
+
+emit() {
+  printf '{"company":"%s","source":"%s"}\n' "$1" "$2"
+  exit 0
+}
+
+if [ -z "$ROOT" ]; then
+  ROOT="${HQ_ROOT:-${CLAUDE_PROJECT_DIR:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && cd .. && pwd)}}"
+fi
+
+MANIFEST="$ROOT/companies/manifest.yaml"
+[ -f "$MANIFEST" ] || emit "" "none"
+
+SLUGS="$(
+  awk '
+    function keep(slug) {
+      return slug != "" && slug != "_template" && slug != "companies" && slug != "unaffiliated_repos"
+    }
+    /^companies:[[:space:]]*$/ { wrapped = 1; next }
+    wrapped && /^[^[:space:]][^:]*:[[:space:]]*$/ { wrapped = 0 }
+    wrapped && /^  [A-Za-z][A-Za-z0-9_-]*:/ {
+      line = $0; sub(/^[[:space:]]+/, "", line); sub(/:.*/, "", line)
+      if (keep(line)) print line
+      next
+    }
+    !wrapped && /^[A-Za-z][A-Za-z0-9_-]*:/ {
+      line = $0; sub(/:.*/, "", line)
+      if (keep(line)) print line
+    }
+  ' "$MANIFEST" | sort -u
+)"
+[ -n "$SLUGS" ] || emit "" "none"
+
+is_known_slug() {
+  printf '%s\n' "$SLUGS" | grep -Fxq "$1"
+}
+
+prompt_slug() {
+  local normalized="" match=""
+  [ -n "$PROMPT" ] || return 0
+  normalized="$(printf '%s' "$PROMPT" | tr '[:upper:]' '[:lower:]' | tr -c 'a-z0-9_-' ' ')"
+  match="$(
+    # Prompt normalization is case-insensitive, but company IDs are not.
+    # Keep a folded match only when exactly one registered ID has that key.
+    # If IDs differ only by case, do not guess which tenant the prompt means.
+    printf '%s\n' "$SLUGS" | awk -v line="$normalized" '
+      BEGIN {
+        n = split(line, tok, /[ \t]+/)
+        for (i = 1; i <= n; i++) if (tok[i] != "" && !(tok[i] in pos)) pos[tok[i]] = i
+        bestSlug = ""; bestLen = 0; bestPos = 0
+      }
+      {
+        slug = $0
+        key = tolower(slug)
+        if (key in pos) {
+          matches[key]++
+          candidate[key] = slug
+        }
+      }
+      END {
+        for (key in matches) {
+          if (matches[key] != 1) continue
+          slug = candidate[key]
+          len = length(slug); p = pos[key]
+          if (len > bestLen || (len == bestLen && p < bestPos)) {
+            bestSlug = slug; bestLen = len; bestPos = p
+          }
+        }
+        if (bestSlug != "") print bestSlug
+      }
+    '
+  )"
+  printf '%s' "$match"
+}
+
+MATCH="$(prompt_slug)"
+[ -n "$MATCH" ] && emit "$MATCH" "prompt"
+
+SESSION_CO=""
+if [ -x "$ROOT/core/scripts/hq-session.sh" ]; then
+  SESSION_CO="$(bash "$ROOT/core/scripts/hq-session.sh" get company_slug 2>/dev/null || true)"
+  SESSION_CO="$(printf '%s' "$SESSION_CO" | tr -d '[:space:]\"')"
+fi
+if [ -n "$SESSION_CO" ] && is_known_slug "$SESSION_CO"; then
+  emit "$SESSION_CO" "session"
+fi
+
+is_fleet_identity() {
+  [ -n "${HQ_AGENT_WORKDIR:-}" ] && return 0
+  [ -n "${HQ_AGENT_COMPANY_DIR:-}" ] && return 0
+  [ -n "${HQ_AGENT_IDENTITY_FILE:-}" ] && return 0
+  [ -f /etc/hq-agent/identity.json ] && return 0
+  [ -f /etc/hq-agent/machine-creds.json ] && return 0
+  agent_root="${HQ_AGENT_ROOT_PREFIX:-}"
+  if [ -n "$agent_root" ]; then
+    [ -f "${agent_root%/}/var/lib/hq-agent/identity.json" ] && return 0
+  else
+    [ -f /var/lib/hq-agent/identity.json ] && return 0
+  fi
+  [ -f /var/lib/hq-agent/machine-creds.json ] && return 0
+  return 1
+}
+
+run_with_timeout() {
+  command -v node >/dev/null 2>&1 || return 127
+  node -e '
+const { spawn } = require("child_process");
+const command = process.argv[1];
+if (!command) process.exit(127);
+const child = spawn(command, process.argv.slice(2), { detached: true, stdio: ["ignore", "pipe", "ignore"] });
+let finished = false;
+const finish = (status) => {
+  if (finished) return;
+  finished = true;
+  clearTimeout(timer);
+  try { process.kill(-child.pid, "SIGTERM"); } catch (_) {}
+  process.exit(status);
+};
+child.stdout.on("data", (chunk) => process.stdout.write(chunk));
+child.once("error", () => finish(127));
+child.once("exit", (code) => finish(typeof code === "number" ? code : 1));
+const timer = setTimeout(() => finish(124), 2000);
+' "$@"
+}
+
+if ! is_fleet_identity && command -v hq >/dev/null 2>&1 && command -v jq >/dev/null 2>&1; then
+  DEFAULT_JSON="$(run_with_timeout hq mesh context default get --json 2>/dev/null || true)"
+  DEFAULT_SLUG="$(printf '%s' "$DEFAULT_JSON" | jq -er '(.defaultCompany // .) as $default | if $default.enabled == true and ($default.source // "") != "disabled" and ($default.needsChoice // false) == false and ($default.slug | type == "string") then $default.slug else empty end' 2>/dev/null || true)"
+  DEFAULT_SLUG="$(printf '%s' "$DEFAULT_SLUG" | tr -d '[:space:]\"')"
+  if [ -n "$DEFAULT_SLUG" ] && is_known_slug "$DEFAULT_SLUG"; then
+    # A device default is only a local preference. Reconcile performs the
+    # token-backed active-membership check; never promote this fallback when
+    # that preflight is unavailable, times out, or returns a noncanonical row.
+    PREFLIGHT_SESSION_ID="resolve-default-$$-$RANDOM"
+    PREFLIGHT_OPERATION_ID="resolve-default-op-$$-$RANDOM"
+    PREFLIGHT_OBSERVATION="$(jq -cn \
+      --arg session_id "$PREFLIGHT_SESSION_ID" \
+      --arg operation_id "$PREFLIGHT_OPERATION_ID" \
+      --arg root "$ROOT" \
+      '{contractVersion:1,clientOperationId:$operation_id,identity:{sessionId:$session_id,harness:"hq-core",adapterVersion:"1"},cwd:$root,hqRoot:$root}')"
+    PREFLIGHT_STATUS=0
+    PREFLIGHT_RESULT="$(run_with_timeout hq mesh context reconcile --observation-json "$PREFLIGHT_OBSERVATION" --machine --offline 2>/dev/null)" || PREFLIGHT_STATUS=$?
+    VALIDATED_SLUG=""
+    if [ "$PREFLIGHT_STATUS" -eq 0 ]; then
+      VALIDATED_SLUG="$(printf '%s' "$PREFLIGHT_RESULT" | jq -er \
+        --arg slug "$DEFAULT_SLUG" \
+        --arg session_id "$PREFLIGHT_SESSION_ID" \
+        --arg operation_id "$PREFLIGHT_OPERATION_ID" '
+          if type == "object"
+            and .contractVersion == 1
+            and (.sessionId | type == "string") and .sessionId == $session_id
+            and (.clientOperationId | type == "string") and .clientOperationId == $operation_id
+            and (.kind == "queued" or .kind == "needs_project" or .kind == "needs_task" or .kind == "bound")
+            and (.classification == "needs_project" or .classification == "needs_task" or .classification == "bound")
+            and (.delivery == "queued" or .delivery == "acked")
+            and .lifecycle == "open"
+            and .companySlug == $slug
+            and (.companyUid | type == "string") and (.companyUid | length > 0)
+          then .companySlug else empty end
+        ' 2>/dev/null || true)"
+    fi
+    [ "$VALIDATED_SLUG" = "$DEFAULT_SLUG" ] && emit "$DEFAULT_SLUG" "device_default"
+  fi
+fi
+
+emit "" "none"