cue-ai 0.9.1 → 0.9.2

package/CHANGELOG.md

@@ -0,0 +1,40 @@
+# Changelog
+
+All notable changes to cue (`cue-ai`) are documented here.
+The format follows [Keep a Changelog](https://keepachangelog.com/), and the project
+adheres to [Semantic Versioning](https://semver.org/).
+
+## [0.9.2] — 2026-06-05
+
+### Added
+
+- **Live code-review visibility.** Watch an independent review move file-by-file in
+  real time instead of staring at an opaque "Precipitating…" spinner.
+  - `bin/cue-review-watch` — live renderer; run it in a second pane to follow the
+    latest review (`--id <id>` for a specific one, `--once` for a snapshot).
+  - `bin/cue-review-progress` — append-only progress events to
+    `~/.config/cue/review-progress/<id>.jsonl` (the shared schema every reviewer writes).
+  - `/code-review` now emits per-file / per-dimension / per-finding progress events.
+  - The `auto-review` Stop-hook gate streams its review to the same log, so the
+    independent merge-gate review is watchable live too (invariants unchanged:
+    recursion guard, fail-open, binary verdict).
+  - Docs: [`docs/review-visibility.md`](./docs/review-visibility.md).
+- **Self-learner (experimental · opt-in · default-OFF).** Profiles capture where their
+  skills fell short during a task and feed gated improvements back over time.
+  - `resources/hooks/profile-self-improve.sh` — friction-signal capture plus an optional
+    live critic agent. Recursion-guarded, never blocks Stop, runs the critic at most once
+    per session, fully fail-open.
+  - New `skill_gap` analytics event (`src/lib/analytics.ts`), inert to existing readers.
+  - Piloted on the `skill-writer` profile. Enable with
+    `touch ~/.config/cue/.auto-improve-enabled`. Docs: [`docs/self-learner.md`](./docs/self-learner.md).
+
+### Documentation
+
+- **README — "what you'll see during a run — the reviewer".** Explains the independent
+  review gate that runs during a Claude Code session: why a red "Stop hook error" means
+  the gate is working (not a failure), how to suppress or disable it, and how to watch a
+  review live with `cue-review-watch`. Includes a real catch (a `weight` kg/g unit
+  ambiguity that would have rendered per-kg prices as `€0.00`).
+
+[0.9.2]: https://github.com/opencue/cuecards/compare/v0.9.1...v0.9.2
+[0.9.1]: https://github.com/opencue/cuecards/releases/tag/v0.9.1

package/README.md

@@ -220,6 +220,44 @@ Full system + when each tag fires: **[`resources/skills/skills/meta/integrity-ta
 
 ---
 
+## what you'll see during a run — the reviewer.
+
+cuecards can ship an **independent review gate**. When the agent finishes a
+code-producing turn in a cuecard that enables it, cue spawns a *fresh, separate*
+reviewer agent over the working-tree diff **before the turn is allowed to finish**.
+It runs as a normal step of a Claude Code run — so expect to see a reviewer agent
+think for a while (a deep pass can run many minutes and tens of thousands of tokens).
+This is by design, and it earns its keep.
+
+A real catch from a live session: the reviewer flagged a **load-bearing unit bug** —
+a product's `weight` was treated as kilograms in one place but grams in two others
+(`weight >= 1000 ? kg : g`). Left in, the per-kg price renders as `€0.00` and a cart
+reads `20000 kg`. The gate held the merge until it was fixed.
+
+Two things so the behavior isn't surprising:
+
+- **A red "Stop hook error" is the gate working, not a failure.** Claude Code renders
+  any *blocking* hook that way. It means the reviewer found a CRITICAL/HIGH issue and is
+  holding the turn until you address it. It caps at 2 rounds, then releases. Suppress it
+  for one turn with `[skip-auto-review]` in your message; turn it off entirely with
+  `rm ~/.config/cue/auto-review-enabled`.
+- **You can watch the review live.** A long review otherwise shows only a spinner. Run
+  `cue-review-watch` in a second pane to see it move file-by-file with findings as they land:
+
+```
+16:42:03  📄 setup-plate-variants.ts
+16:42:03     → unit convention
+16:42:09     🔴 CRITICAL  weight kg/g ambiguity → per-kg price shows €0.00
+16:45:30  ✅ review complete  1 CRITICAL
+```
+
+Enable the gate with `touch ~/.config/cue/auto-review-enabled`. Full details:
+[`docs/review-visibility.md`](./docs/review-visibility.md).
+
+<br>
+
+---
+
 ## the catalog.
 
 > One repo. 69 pre-built expert agents. Pin one with `cue use <name>` and `claude` launches with that cuecard's skills, MCPs, hooks, and commands materialized.

package/bin/cue-review-progress

@@ -0,0 +1,107 @@
+#!/usr/bin/env bash
+# cue-review-progress — emit live code-review progress events to a tail-able JSONL
+# so `cue-review-watch` (or a dashboard panel) can show what a reviewer is doing
+# in REAL TIME instead of an opaque spinner. No external deps.
+#
+# Any reviewer (the auto-review Stop hook, a code-reviewer subagent, /ship Step 9,
+# a review workflow) appends one event per file / dimension / finding. The shared
+# schema is the contract — see docs/review-visibility.md.
+#
+# Storage: ~/.config/cue/review-progress/<id>.jsonl   (append-only)
+#          ~/.config/cue/review-progress/latest        (pointer file holding <id>)
+#
+# Event schema (one JSON object per line):
+#   ts        ISO-8601 UTC (auto)
+#   id        review id
+#   kind      start | file | dim | finding | note | end
+#   file      path under review            (file/dim/finding)
+#   dim       dimension/lens being checked (dim/finding)
+#   severity  CRITICAL|HIGH|MEDIUM|LOW     (finding)
+#   title     short text                   (finding/note/start/end)
+#   detail    longer text                  (optional)
+#
+# Usage:
+#   cue-review-progress start  [--id <id>] [--label <text>] [--files <n>]   # prints id
+#   cue-review-progress emit   [--id <id>] --kind <file|dim|finding|note> \
+#                              [--file <p>] [--dim <d>] [--severity <S>] \
+#                              [--title <t>] [--detail <x>]
+#   cue-review-progress end    [--id <id>] [--summary <text>]
+#   cue-review-progress path   [--id <id>]        # print the jsonl path
+#   cue-review-progress latest                    # print current latest id
+set -euo pipefail
+
+DIR="${XDG_CONFIG_HOME:-$HOME/.config}/cue/review-progress"
+mkdir -p "$DIR"
+
+# JSON string escape: drop C0 control chars (a raw tab/newline breaks the line),
+# then escape backslash and double-quote.
+esc() { printf '%s' "${1:-}" | tr -d '\000-\037' | sed 's/\\/\\\\/g; s/"/\\"/g'; }
+now() { date -u +%Y-%m-%dT%H:%M:%S.000Z; }
+
+resolve_id() { # $1 = explicit id (may be empty)
+  if [[ -n "${1:-}" ]]; then printf '%s' "$1"; return; fi
+  if [[ -r "$DIR/latest" ]]; then head -1 "$DIR/latest"; return; fi
+  printf ''
+}
+
+cmd="${1:-}"; shift || true
+ID="" KIND="" FILE="" DIM="" SEV="" TITLE="" DETAIL="" LABEL="" FILES="" SUMMARY=""
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --id)       ID="$2"; shift 2 ;;
+    --kind)     KIND="$2"; shift 2 ;;
+    --file)     FILE="$2"; shift 2 ;;
+    --dim)      DIM="$2"; shift 2 ;;
+    --severity) SEV="$2"; shift 2 ;;
+    --title)    TITLE="$2"; shift 2 ;;
+    --detail)   DETAIL="$2"; shift 2 ;;
+    --label)    LABEL="$2"; shift 2 ;;
+    --files)    FILES="$2"; shift 2 ;;
+    --summary)  SUMMARY="$2"; shift 2 ;;
+    *) echo "cue-review-progress: unknown flag $1" >&2; exit 1 ;;
+  esac
+done
+
+append() { # $1 = full json object (without trailing newline)
+  printf '%s\n' "$1" >> "$DIR/$RID.jsonl"
+}
+
+case "$cmd" in
+  start)
+    RID="${ID:-rev-$(date -u +%Y%m%dT%H%M%SZ)-$$}"
+    printf '%s' "$RID" > "$DIR/latest"
+    : > "$DIR/$RID.jsonl"
+    append "$(printf '{"ts":"%s","id":"%s","kind":"start","title":"%s","detail":"%s"}' \
+      "$(now)" "$(esc "$RID")" "$(esc "$LABEL")" "$(esc "$FILES")")"
+    printf '%s\n' "$RID"
+    ;;
+  emit)
+    RID="$(resolve_id "$ID")"
+    [[ -z "$RID" ]] && { echo "cue-review-progress emit: no review id (run 'start' first or pass --id)" >&2; exit 1; }
+    case "$KIND" in
+      file|dim|finding|note) ;;
+      "") echo "cue-review-progress emit: --kind required (file|dim|finding|note)" >&2; exit 1 ;;
+      *)  echo "cue-review-progress emit: invalid --kind '$KIND'" >&2; exit 1 ;;
+    esac
+    append "$(printf '{"ts":"%s","id":"%s","kind":"%s","file":"%s","dim":"%s","severity":"%s","title":"%s","detail":"%s"}' \
+      "$(now)" "$(esc "$RID")" "$KIND" "$(esc "$FILE")" "$(esc "$DIM")" "$(esc "$SEV")" "$(esc "$TITLE")" "$(esc "$DETAIL")")"
+    ;;
+  end)
+    RID="$(resolve_id "$ID")"
+    [[ -z "$RID" ]] && exit 0
+    append "$(printf '{"ts":"%s","id":"%s","kind":"end","title":"%s"}' \
+      "$(now)" "$(esc "$RID")" "$(esc "$SUMMARY")")"
+    ;;
+  path)
+    RID="$(resolve_id "$ID")"; [[ -z "$RID" ]] && { echo "no review yet" >&2; exit 1; }
+    printf '%s\n' "$DIR/$RID.jsonl"
+    ;;
+  latest)
+    [[ -r "$DIR/latest" ]] && head -1 "$DIR/latest" || { echo "no review yet" >&2; exit 1; }
+    ;;
+  ""|-h|--help|help)
+    sed -n '2,/^set -e/p' "$0" | sed 's/^# \{0,1\}//; s/^set -.*//'
+    ;;
+  *)
+    echo "cue-review-progress: unknown subcommand '$cmd' (start|emit|end|path|latest)" >&2; exit 1 ;;
+esac

package/bin/cue-review-watch

@@ -0,0 +1,98 @@
+#!/usr/bin/env bash
+# cue-review-watch — live view of a code review in progress. Run it in a second
+# pane and watch the reviewer move file-by-file, dimension-by-dimension, with
+# findings as they land — instead of an opaque "Precipitating…" spinner.
+#
+# Reads the JSONL written by cue-review-progress (and the auto-review Stop hook).
+#
+# Usage:
+#   cue-review-watch                # follow the latest review, live
+#   cue-review-watch --id <id>      # follow a specific review
+#   cue-review-watch --once         # print what's there so far and exit (no follow)
+set -euo pipefail
+
+DIR="${XDG_CONFIG_HOME:-$HOME/.config}/cue/review-progress"
+ID="" ONCE=0
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --id)   ID="$2"; shift 2 ;;
+    --once) ONCE=1; shift ;;
+    -h|--help) grep '^#' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;;
+    *) echo "cue-review-watch: unknown flag $1" >&2; exit 1 ;;
+  esac
+done
+
+# Colors only on a tty.
+if [[ -t 1 ]]; then
+  B=$'\033[1m'; D=$'\033[2m'; R=$'\033[31m'; Y=$'\033[33m'; G=$'\033[32m'; C=$'\033[36m'; M=$'\033[35m'; Z=$'\033[0m'
+else
+  B="" D="" R="" Y="" G="" C="" M="" Z=""
+fi
+
+have_jq=0; command -v jq >/dev/null 2>&1 && have_jq=1
+
+get() { # $1=field  (reads $line); jq if present, grep fallback
+  if [[ $have_jq -eq 1 ]]; then
+    printf '%s' "$line" | jq -r --arg f "$1" '.[$f] // ""' 2>/dev/null
+  else
+    printf '%s' "$line" | grep -oE "\"$1\"[[:space:]]*:[[:space:]]*\"[^\"]*\"" | head -1 \
+      | sed -E "s/.*\"$1\"[[:space:]]*:[[:space:]]*\"([^\"]*)\".*/\1/"
+  fi
+}
+
+hhmmss() { printf '%s' "${1:-}" | sed -E 's/.*T([0-9:]{8}).*/\1/'; }
+
+render() { # reads $line
+  local kind ts t file dim sev title detail
+  kind="$(get kind)"; [[ -z "$kind" ]] && return 0
+  ts="$(get ts)"; t="$(hhmmss "$ts")"
+  file="$(get file)"; dim="$(get dim)"; sev="$(get severity)"; title="$(get title)"; detail="$(get detail)"
+  case "$kind" in
+    start)   printf '%s%s▶ review started%s %s%s%s\n' "$D$t  $Z" "$B$C" "$Z" "$D" "${detail:+($detail files) }${title}" "$Z" ;;
+    file)    printf '%s%s📄 %s%s\n' "$D$t  $Z" "$B" "$file" "$Z" ;;
+    dim)     printf '%s   %s→ %s%s\n' "$D$t  $Z" "$C" "$dim" "$Z" ;;
+    finding)
+      local col gl
+      case "$sev" in
+        CRITICAL) col="$R$B"; gl="🔴" ;;
+        HIGH)     col="$R";   gl="🟠" ;;
+        MEDIUM)   col="$Y";   gl="🟡" ;;
+        *)        col="$D";   gl="⚪" ;;
+      esac
+      printf '%s     %s%s %s%s %s%s\n' "$D$t  $Z" "$col" "$gl" "${sev:-NOTE}" "$Z" "${file:+$file${dim:+ · $dim}  }" "$title"
+      [[ -n "$detail" ]] && printf '          %s%s%s\n' "$D" "$detail" "$Z"
+      ;;
+    note)    printf '%s   %s· %s%s\n' "$D$t  $Z" "$D" "${title}${detail:+: $detail}" "$Z" ;;
+    end)     printf '%s%s✅ review complete%s %s%s%s\n' "$D$t  $Z" "$B$G" "$Z" "$D" "$title" "$Z" ;;
+  esac
+}
+
+# Resolve the review id / file.
+[[ -z "$ID" && -r "$DIR/latest" ]] && ID="$(head -1 "$DIR/latest")"
+if [[ -z "$ID" ]]; then
+  echo "${D}cue-review-watch: no review yet. Start one, or a reviewer will.${Z}" >&2
+fi
+
+# Wait for the file to appear (a reviewer may not have started yet).
+file_path="$DIR/${ID:-__none__}.jsonl"
+if [[ ! -e "$file_path" ]]; then
+  printf '%swaiting for a review to start (%s)…%s\n' "$D" "$DIR" "$Z"
+  while [[ ! -e "$file_path" ]]; do
+    # latest may update to a new id while we wait
+    [[ -r "$DIR/latest" ]] && ID="$(head -1 "$DIR/latest")" && file_path="$DIR/$ID.jsonl"
+    sleep 1
+  done
+fi
+
+printf '%swatching %s%s\n\n' "$D" "$file_path" "$Z"
+
+if [[ $ONCE -eq 1 ]]; then
+  while IFS= read -r line; do render; done < "$file_path"
+  exit 0
+fi
+
+# Follow live. -F keeps following across truncation/rotation.
+tail -n +1 -F "$file_path" 2>/dev/null | while IFS= read -r line; do
+  render
+  printf '%s' "$(get kind)" | grep -q '^end$' && break || true
+done

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cue-ai",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "description": "cue — Agent Profile Manager for Claude Code & Codex. Pick a profile, launch with the right skills, MCPs, and plugins.",
   "type": "module",
   "bin": {
@@ -68,6 +68,7 @@
     "install.sh",
     "get.sh",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE"
   ],
   "dependencies": {

package/profiles/career/profile.yaml

@@ -18,7 +18,11 @@ persona: |
   - **Story > list.** Interview answers follow STAR (Situation, Task, Action,
     Result) with the Result quantified.
 skills:
-  local: []
+  local:
+    # Coverage not in the npx entries below: comp-band research + resume
+    # version tracking. Materialized from .claude/skills into the submodule.
+    - career/salary-negotiation-prep
+    - career/resume-version-manager
   npx:
     # Top community skills surfaced via `cue sources search resume/career`.
     # Install counts (as of 2026-05-29) reflect community validation.
@@ -28,4 +32,11 @@ skills:
       skills: [resume-builder]            # 223 installs — Reactive Resume integration
     - repo: santifer/career-ops
       skills: [career-ops]                # 151 installs — broader career management
-mcps: []
+    # Proficiently — integrated job-search suite (setup → search → tailor →
+    # cover → apply → network → telegram). Shares ~/.proficiently/ state.
+    - repo: proficientlyjobs/proficiently-claude-skills
+      skills: [setup, job-search, tailor-resume, cover-letter, network-scan, apply, jobsearch-telegram]
+mcps:
+  # Browser automation — powers the Proficiently suite: apply fills
+  # Greenhouse/Lever/Workday forms, job-search/network-scan scrape boards.
+  - playwright

package/profiles/core/profile.yaml

@@ -82,6 +82,7 @@ persona: |
   (sprint, ship-feature, triage-bug), read it first.
 skills:
   local:
+    - meta/focus
     # ── Built-in essentials: shared by every cue profile via inheritance ──
     - meta/analyze              # investigation: "analyze", "why does", "what's causing"
     - meta/cue-usage            # cue CLI guidance
@@ -129,6 +130,7 @@ mcps:
   - cue-tty-watch    # Claude's eyes inside X displays / tmux panes (screenshot, capture-pane, send-keys)
   - lightpanda       # Fast headless browser MCP — fetch/render/scrape URLs without Chromium. Pairs with browser/lightpanda skill.
   - context7         # Up-to-date, version-specific library docs (Upstash @upstash/context7-mcp). No API key needed; set CONTEXT7_API_KEY for higher limits. Pairs with tools/context7 skill.
+  - codegraph        # CodeGraph MCP (`codegraph serve --mcp`): structural code search — callers, callees, impact, definitions, signatures. No-op in repos without a `.codegraph/` index (run `codegraph init -i`). Fans out to every core-inheriting profile.
 plugins:
   - claude-mem@thedotmack
   # Disabled 2026-05-30: OMC's PreToolUse auto-mode classifier was intermittently
@@ -172,6 +174,12 @@ hooks:
   # Universal analytics: append one line per session-end to ~/.config/cue/session-log.jsonl
   # so `cue eval` sees real usage data for every profile, not just gstack.
   - session-summary.json
+  # SessionStart hook: inject this project's most recent cue-learnings entries
+  # as context, so a fresh session inherits captured lessons instead of
+  # repeating past mistakes — the read side of the bin/cue-learnings loop
+  # (capture side is the skill-evolution persona). Fail-open; no-op when the
+  # project has no learnings.jsonl. Opt out with CUE_LEARNINGS_CONTEXT=0.
+  - learnings-context.json
   # Refuse writes to .env, id_rsa, credentials.json, .pem/.key, ~/.ssh, ~/.aws, etc.
   - secrets-guard.json
   # Reject low-effort `git commit -m "wip"` / "fix" / "update" messages.

package/profiles/eu-tender-research/README.md

@@ -0,0 +1,48 @@
+# 🏛️ eu-tender-research
+
+EU funding research for **agentic AI companies in Slovakia or Hungary**. Two jobs in one
+profile: find public-procurement **tenders** to bid on, and map the **grants, cheap loans,
+and venture capital** a company can apply for. Built so the second run is faster, cheaper,
+and more accurate than the first.
+
+## Two channels, two skills
+
+| You want to... | Skill | Source |
+|---|---|---|
+| Find EU tenders to bid on | `eu-funding/ted-tender-search` | Official TED API (free, no key) |
+| Find grants / loans / VC for a company | `eu-funding/hu-grant-finder` | palyazat.gov.hu, NKFIH, MFB, Hiventures, EIC |
+
+Both skills carry the **verified recipes** so the agent doesn't rediscover them:
+the TED API endpoint + Expert-Search query language, the Hungarian funding ladder,
+the canonical sources, and the eligibility gotchas that disqualify fastest.
+
+## The funding channels (the #1 thing users confuse)
+
+- **Tender / közbeszerzés** — TED procurement: you *sell* services to the state.
+- **Grant / támogatás** — GINOP/DIMOP: non-repayable project money.
+- **Loan / hitel** — MFB / GINOP 1.4.x: cheap (often 0%) but you repay.
+- **VC / kockázati tőke** — Hiventures (GINOP 2.5.1), EIC: equity investment.
+
+## Gotchas baked into the persona
+
+- **Closed-year wall** — most KKV grants/loans need ≥1 closed business year. An egyéni
+  vállalkozó's closed tax year counts; don't found a fresh Kft and reset the clock.
+- **Region split** — DIMOP/GINOP: Budapest (`/C`) vs every other county (`/B`, favoured).
+- **Timing** — frames close on *forráskimerülés*, often before the deadline; re-check live.
+- **VC is not free** — equity + TRL6 product; GINOP 2.5.1 excludes "only software" firms.
+- **Deep-tech ≠ SaaS** — an LLM-wrapper won't win EIC; Hungary's route is EIC Pre-Accelerator.
+
+## MCPs
+
+`ted-eu` (free single-notice fetch), `lightpanda` (page render), `gbrain` (track
+shortlisted opportunities across sessions). No paid scraper, no API token. Apify is
+re-addable if ever wanted: `cue mcps add apify-ted-eu` (needs `APIFY_API_TOKEN`).
+
+## Use it
+
+```bash
+cue use eu-tender-research
+```
+
+Then ask things like *"find open IT tenders from Hungarian buyers"* or *"what grants can a
+new Hungarian AI company apply for?"* — the matching skill activates and runs the verified flow.

package/profiles/eu-tender-research/profile.yaml

@@ -0,0 +1,108 @@
+name: eu-tender-research
+icon: "🏛️"
+iconImage: "logo.png"
+description: "EU funding research for agentic AI companies in Slovakia or Hungary: TED tenders + grants/loans/VC (GINOP, DIMOP, Hiventures, EIC). Find, filter, assess eligibility, draft briefs."
+agents: [claude-code]
+inherits: core
+skills:
+  local:
+    - eu-funding/ted-tender-search
+    - eu-funding/hu-grant-finder
+    - eu-funding/grant-outreach
+    - research/find-skills
+    - research/defuddle
+    - research/trendradar
+    - gstack/scrape
+    - gstack/document-generate
+    - gstack/make-pdf
+    - content/article-writer
+mcps:
+  - lightpanda
+  - gbrain
+  - trendradar
+env:
+  EU_TENDER_HQ_COUNTRIES: "SK,HU"
+  TED_API_BASE: "https://api.ted.europa.eu/v3"
+persona: |
+  You run EU funding research for agentic AI companies headquartered in
+  Slovakia (SK) or Hungary (HU). Two jobs: (1) surface TED procurement
+  tenders these firms can bid on, and (2) map the grants, cheap loans, and
+  venture capital they can apply for. Rank by fit and eligibility, then turn
+  winners into a clean brief.
+
+  ## Funding channels (DON'T conflate them, this is the #1 user confusion)
+
+  | Channel | What it is | Lead skill |
+  |---|---|---|
+  | Tender / közbeszerzés | TED procurement, you *sell* to the state | `eu-funding/ted-tender-search` |
+  | Grant / támogatás | GINOP/DIMOP, non-repayable | `eu-funding/hu-grant-finder` |
+  | Cheap loan / hitel | MFB / GINOP 1.4.x, 0% but repay | `eu-funding/hu-grant-finder` |
+  | Venture capital | Hiventures (GINOP 2.5.1), EIC, equity | `eu-funding/hu-grant-finder` |
+
+  The two `eu-funding/*` skills carry the verified recipes (TED API query
+  language, the Hungarian funding ladder, the sources, the eligibility
+  gotchas). Read the matching skill first, don't rediscover the endpoint or
+  the gotchas from scratch.
+
+  ## Gotchas that gate everything (check before detailing amounts)
+
+  - **Closed-year wall** — most KKV grants/loans need >=1 closed business
+    year + 1 employee; a brand-new company can't apply day one. An egyeni
+    vallalkozo's closed tax year counts, so don't found a fresh Kft and
+    reset that clock.
+  - **Region split** — DIMOP/GINOP is Budapest (`/C`) vs every other county
+    (`/B`, "less developed"); wealthy counties are in the favoured `/B`.
+  - **Timing** — frames close on forraskimerules, often before the deadline;
+    re-check the live active list at palyazat.gov.hu the same day.
+  - **VC is not free** — Hiventures/EIC take equity, need a TRL6 working
+    product, and GINOP 2.5.1 excludes "only software" firms.
+  - **Deep-tech vs SaaS** — an LLM-wrapper is SaaS, not deep tech; EIC wants
+    breakthrough. Hungary is a "widening" country, so EIC Pre-Accelerator is
+    the realistic stepping stone.
+
+  ## Data sources (route by need)
+
+  | Need                                                              | Tool                          |
+  |-------------------------------------------------------------------|-------------------------------|
+  | Search TED notices (CPV, country, deadline, value) — free, no key | Official TED API, `${TED_API_BASE}/notices/search` (POST) |
+  | Fetch one notice in full by publication number                    | Same TED API: `query: "publication-number IN (123456-2025)"` |
+  | Render a TED portal page that the API can't reach                 | `lightpanda` MCP, gstack/scrape |
+  | Strip a notice page to clean text                                 | research/defuddle             |
+  | Track shortlisted tenders + buyer contacts across sessions        | `gbrain` MCP                  |
+  | Spot which procurement themes are heating up                      | research/trendradar           |
+  | Draft a bid summary / capability statement                        | content/article-writer        |
+  | Export the brief as a shareable doc/PDF                           | gstack/document-generate, gstack/make-pdf |
+
+  ## Defaults
+
+  - **Fit before volume.** A relevant notice an SK/HU agentic-AI firm can win
+    beats ten generic IT tenders. Filter hard on CPV codes for software, AI,
+    data, and consulting services (72xxxxxx, 48xxxxxx, 73xxxxxx), buyer
+    country, deadline still open, and eligibility (no incumbent lock-in).
+  - **Source every notice.** Each tender in a brief carries its TED
+    publication number (e.g. `123456-2025`), buyer, country, value, deadline,
+    and the live notice URL. No number, not in the brief.
+  - **Rank, don't dump.** When you produce a list of tenders (3+), run
+    `/roi-estimator` so each row carries a fit/value tag the user can sort by.
+  - **Both bid angles.** A notice can fit either as the prime bidder or as a
+    subcontractor to a local integrator — flag which when it's not obvious.
+  - **Verify before claiming done.** Confirm a notice is still open and the
+    publication number resolves before putting it in front of the user.
+
+  ## Free stack, no credentials
+
+  Everything here runs without an API key or paid scraper:
+
+  - **Search** is the official EU TED API at `${TED_API_BASE}/notices/search`
+    (POST JSON `{query, fields, limit, scope:"ACTIVE"}`). The Expert Search
+    query language filters on `classification-cpv`, `place-of-performance`,
+    `deadline-date`, `notice-type`, etc. No key needed.
+    Example: `classification-cpv IN (72000000) AND place-of-performance IN (SVK HUN)`.
+  - **Single-notice detail** comes from the same API:
+    `query: "publication-number IN (123456-2025)"`, `scope: "ALL"`. No MCP needed.
+  - **Page scraping** uses `lightpanda` + `defuddle` locally — no cloud
+    scraper (Apify, Firecrawl, etc.) required.
+  - **Why no TED MCP:** the `ted-eu` gateway exposes 22 tools for 2 useful
+    ones, and its search is an NL-router black box. The API above is precise,
+    verified, and zero-bloat. Re-add it only if you want NL queries:
+    `cue mcps add ted-eu` (or `apify-ted-eu`, needs `APIFY_API_TOKEN`).

package/profiles/gstack/profile.yaml

@@ -74,6 +74,8 @@ skills:
     - gstack/health
     # gitguardex (gx) — worktree/lock/PR safety + the gated auto-ship flow
     - github/gitguardex
+    # gx mcp agent radar — see who's on which branch/PR/file, avoid collisions
+    - github/gx-agents
 # MCPs: cue-tty-watch + lightpanda inherited from core. gbrain dropped along
 # with the setup-gbrain / sync-gbrain skills.
 rules:

package/profiles/skill-writer/profile.yaml

@@ -118,6 +118,10 @@ commands:
 
 hooks:
   - skill-frontmatter-guard.json
+  # cue self-learner (pilot) — captures where this profile's skills fall short
+  # and (with the live critic) judges the gap, feeding `cue profile self-improve`.
+  # OFF until `touch ~/.config/cue/.auto-improve-enabled`. See docs/self-learner.md.
+  - profile-self-improve.json
 
 mcps:
   - gbrain

package/profiles/x-growth-bot/profile.yaml

@@ -9,13 +9,11 @@ skills:
   local:
     # The operator surface: routes each request to the xbot MCP / botctl / cli
     # and enforces the loop-vs-MCP live-write safety rule.
-    - xbot/operate
 
 # The bot's MCP control surface (~27 tools: xbot_status, xbot_think, xbot_reply,
 # xbot_dm, xbot_cycle, xbot_pause, xbot_control, ...). core already contributes
 # cue-tty-watch + lightpanda.
 mcps:
-  - xbot
 
 # Quality rules read on-demand (indexed in CLAUDE.md, not inlined).
 rules: