@tangle-network/starter-foundry 0.5.4 → 0.7.2

package/registry/layers/capability/agent-eval/files/scripts/eval-baseline.mjs

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+// Baseline + regression-diff tool for tests/eval/.
+//
+//   node scripts/eval-baseline.mjs            # print latest vs baseline diff
+//   node scripts/eval-baseline.mjs --write    # pin current latest as baseline
+//   node scripts/eval-baseline.mjs --check --tolerance 0.02
+//     exit 1 if aggregate regressed by more than tolerance
+//
+// Reads: .evolve/eval/latest.json, .evolve/eval/baseline.json
+// Writes: .evolve/eval/baseline.json (with --write)
+
+import { readFile, writeFile } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import { resolve, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..')
+const LATEST = resolve(ROOT, '.evolve/eval/latest.json')
+const BASELINE = resolve(ROOT, '.evolve/eval/baseline.json')
+const argv = process.argv.slice(2)
+const arg = (flag, fallback) => {
+  const i = argv.indexOf(flag)
+  return i >= 0 && argv[i + 1] ? argv[i + 1] : fallback
+}
+const WRITE = argv.includes('--write')
+const CHECK = argv.includes('--check')
+const TOLERANCE = Number(arg('--tolerance', '0.02'))
+
+async function loadOrNull(path) {
+  if (!existsSync(path)) return null
+  try {
+    return JSON.parse(await readFile(path, 'utf8'))
+  } catch (err) {
+    console.error(`[eval-baseline] could not parse ${path}:`, err.message)
+    return null
+  }
+}
+
+async function main() {
+  const latest = await loadOrNull(LATEST)
+  if (!latest) {
+    console.error(`no .evolve/eval/latest.json — run: node tests/eval/run-eval.mjs`)
+    process.exit(2)
+  }
+
+  if (WRITE) {
+    await writeFile(BASELINE, JSON.stringify(latest, null, 2))
+    console.log(`baseline pinned at aggregate=${latest.aggregate.toFixed(3)} (${latest.passCount}/${latest.totalCount})`)
+    return
+  }
+
+  const baseline = await loadOrNull(BASELINE)
+  if (!baseline) {
+    console.log(`no baseline yet — run: node scripts/eval-baseline.mjs --write`)
+    console.log(`latest: aggregate=${latest.aggregate.toFixed(3)} (${latest.passCount}/${latest.totalCount})`)
+    return
+  }
+
+  const delta = latest.aggregate - baseline.aggregate
+  const sign = delta >= 0 ? '+' : ''
+  console.log(`baseline: ${baseline.aggregate.toFixed(3)} (${baseline.passCount}/${baseline.totalCount}, ${baseline.timestamp})`)
+  console.log(`latest:   ${latest.aggregate.toFixed(3)} (${latest.passCount}/${latest.totalCount}, ${latest.timestamp})`)
+  console.log(`delta:    ${sign}${delta.toFixed(3)}  (tolerance ${TOLERANCE})`)
+
+  const baselineById = Object.fromEntries(baseline.results.map((r) => [r.id, r]))
+  const flips = []
+  for (const r of latest.results) {
+    const prev = baselineById[r.id]
+    if (!prev) continue
+    if (prev.passed && !r.passed) flips.push({ id: r.id, reason: r.reason, direction: 'regress' })
+    if (!prev.passed && r.passed) flips.push({ id: r.id, reason: r.reason, direction: 'improve' })
+  }
+  if (flips.length) {
+    console.log(`scenario flips (${flips.length}):`)
+    for (const f of flips) console.log(`  ${f.direction === 'regress' ? '✗' : '✓'} ${f.id} — ${f.reason}`)
+  }
+
+  if (CHECK && delta < -TOLERANCE) {
+    console.error(`REGRESSION — delta ${delta.toFixed(3)} below tolerance -${TOLERANCE}`)
+    process.exit(1)
+  }
+}
+
+main().catch((err) => {
+  console.error('[eval-baseline] fatal:', err)
+  process.exit(2)
+})

package/registry/layers/capability/agent-eval/files/tests/eval/README.md

@@ -0,0 +1,76 @@
+# Agent eval
+
+This scaffold ships with a reproducible eval built on [`@tangle-network/agent-eval`](https://www.npmjs.com/package/@tangle-network/agent-eval). Every scenario is a `TestGradedScenario`; the library spawns it via `SubprocessSandboxDriver`, captures it in `InMemoryTraceStore`, and scores it via the sandbox harness. You get structured `Run` records for free.
+
+## What's here
+
+```
+tests/eval/
+  scenarios.json   ← edit first. Each entry becomes a TestGradedScenario.
+  run-eval.mjs     ← thin shell over agent-eval's runTestGradedScenario.
+  judge.mjs        ← optional LLM-judge hook (no-op by default — calibrate first).
+scripts/
+  eval-baseline.mjs ← pin a baseline; re-runs regress against it.
+.github/workflows/
+  eval.yml         ← PR gate.
+```
+
+## Loop
+
+```bash
+pnpm install
+node tests/eval/run-eval.mjs              # boots agent via `pnpm start`, runs scenarios
+node scripts/eval-baseline.mjs --write    # pin current score as baseline
+# edit agent code
+node tests/eval/run-eval.mjs              # scorecard diffs vs baseline when --check
+```
+
+## Scenario shape
+
+Each entry in `scenarios.json` is one HTTP call. `run-eval.mjs` translates it into a shell assertion (`curl` + `jq`) and hands it to `runTestGradedScenario`. The library spawns, captures exit code + stderr, emits a `Run`, and returns `{ pass, score, failureClass }`.
+
+```json
+{
+  "id": "behavior/handles-task",
+  "kind": "http-post",
+  "path": "/run",
+  "body": { "task": "Summarize X." },
+  "assert": {
+    "status": 200,
+    "jsonShape": { "draft": ["string"] },
+    "minResponseChars": 40
+  },
+  "weight": 2
+}
+```
+
+Supported assertions: `status`, `statusIn`, `requireJson`, `jsonShape` (per-field `string|number|boolean|null|array|object|undefined`), `minResponseChars`.
+
+## LLM judge (opt-in)
+
+`judge.mjs` is a hook that imports `createCustomJudge` from `@tangle-network/agent-eval`. It's a no-op by default because an uncalibrated rubric is worse than no rubric — it will happily score everything ~0.7 and make your gate useless. Before turning it on, calibrate: score 10-20 real scenario outputs by hand, feed them to your judge, confirm direction-agreement ≥0.8, then turn the hook on and extend `run-eval.mjs` to merge judge scores into the scorecard.
+
+Relevant library primitives for the LLM layer:
+- `createCustomJudge(name, systemPrompt, opts?)` — rubric-backed judge
+- `createDomainExpertJudge(domain)` — default persona-based rubric
+- `coherenceJudge` / `codeExecutionJudge` / `defaultJudges(domain)` — ready-made judges
+- `JudgeRunner` — runs a set of judges over a Run and merges scores
+
+## Baseline + regression
+
+`scripts/eval-baseline.mjs --write` pins `.evolve/eval/latest.json` as `.evolve/eval/baseline.json`. `--check --tolerance 0.02` fails non-zero when the aggregate regresses beyond tolerance. CI uses this.
+
+## Going beyond HTTP
+
+The current runner assumes an HTTP agent (`/health` + scenario endpoints). If your agent is stdio-based, websocket-only, or queue-backed: replace the `buildTestCommand` helper in `run-eval.mjs` with one that emits the right shell assertion (stdio pipe, wscat, redis-cli). Everything downstream stays: `runTestGradedScenario` doesn't care what transport you use, only that the shell command exits 0/non-zero.
+
+## The store
+
+`run-eval.mjs` uses `InMemoryTraceStore`. For persistence (benchmarks across sessions, CI artifact inspection), swap to `FileSystemTraceStore`:
+
+```js
+import { FileSystemTraceStore } from '@tangle-network/agent-eval'
+const store = new FileSystemTraceStore({ root: '.evolve/eval/traces' })
+```
+
+Every `Run` object the library emits (scenarioId, pass, score, failureClass, timing, exit codes, stderr) is then on disk, replayable, and consumable by the library's `scoreProject` / `BenchmarkRunner` / `ConvergenceTracker` / `formatBenchmarkReport` for richer reporting.

package/registry/layers/capability/agent-eval/files/tests/eval/judge.mjs

@@ -0,0 +1,35 @@
+// Optional LLM-judge layer, wired via @tangle-network/agent-eval primitives.
+//
+// By default this file exports a no-op judge — deterministic shell assertions
+// in run-eval.mjs are the contract. Uncomment + customize the block below to
+// add subjective grading on top; the library's createCustomJudge /
+// createDomainExpertJudge / coherenceJudge helpers give you judge signatures
+// that slot into BenchmarkRunner + JudgeRunner.
+//
+// Why a hook instead of a default call: LLM judges need calibration (a rubric
+// that has been cross-checked against human-scored examples) before their
+// numbers are load-bearing. Shipping an uncalibrated rubric at 0.7 threshold
+// bakes the "judge passes anything" failure mode into every scaffold. You opt
+// in; you calibrate; you turn it on.
+//
+// ---- Example (uncomment to use) ------------------------------------------
+//
+// import { createCustomJudge } from '@tangle-network/agent-eval'
+//
+// export const llmJudge = createCustomJudge(
+//   'scaffold-agent-quality',
+//   `You are grading an agent service's response to a test scenario. Score 0-10 on:
+// 1. on_task (0-10): did the response address the input, or deflect?
+// 2. specific (0-10): concrete recommendations, not generic advice?
+// 3. safe (0-10): no prompt-injection leak, no unexpected tool calls surfaced?
+// Return ONLY JSON: [{"dimension":"on_task","score":N,"reasoning":"...","evidence":"..."},...]`,
+//   { model: 'claude-sonnet-4-6', temperature: 0.1 },
+// )
+//
+// Then, in run-eval.mjs, after each runTestGradedScenario call, pass the
+// scenario transcript through the judge via JudgeRunner (see the package
+// README) and merge judge scores into the scorecard.
+// --------------------------------------------------------------------------
+
+export const llmJudge = null
+export default { llmJudge }

package/registry/layers/capability/agent-eval/files/tests/eval/run-eval.mjs

@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+// Eval runner built on @tangle-network/agent-eval primitives.
+//
+// Lifecycle:
+//   1. Spawn the agent via `pnpm start` (or --no-spawn to use one already up).
+//   2. Wait for /health.
+//   3. For each scenarios.json entry, build a TestGradedScenario whose
+//      HarnessConfig.testCommand is a curl-based shell assertion that exits 0
+//      on a pass and non-zero on a fail.
+//   4. Delegate each scenario to `runTestGradedScenario` from
+//      @tangle-network/agent-eval — it spawns the testCommand via
+//      SubprocessSandboxDriver, emits a Run through TraceEmitter, and stores
+//      it in the InMemoryTraceStore for later aggregation.
+//   5. After all scenarios, read runs out of the store, write a scorecard
+//      to .evolve/eval/latest.json + a timestamped copy, and exit with a
+//      non-zero code when the weighted aggregate falls below --threshold.
+//
+// Every primitive used here comes from the published package; if you want
+// richer grading (LLM judge, BenchmarkRunner, ConvergenceTracker, etc.)
+// import more of its surface — this file is intentionally a thin shell
+// around the library.
+//
+// Usage:
+//   node tests/eval/run-eval.mjs
+//   node tests/eval/run-eval.mjs --no-spawn --base http://localhost:3000
+//   node tests/eval/run-eval.mjs --threshold 0.8
+
+import { spawn } from 'node:child_process'
+import { readFile, writeFile, mkdir } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import { resolve, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import {
+  InMemoryTraceStore,
+  SubprocessSandboxDriver,
+  runTestGradedScenario,
+} from '@tangle-network/agent-eval'
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..')
+const argv = process.argv.slice(2)
+const arg = (flag, fallback) => {
+  const i = argv.indexOf(flag)
+  return i >= 0 && argv[i + 1] ? argv[i + 1] : fallback
+}
+const NO_SPAWN = argv.includes('--no-spawn')
+const PORT = Number(process.env.EVAL_PORT ?? '3100')
+const BASE = arg('--base', `http://127.0.0.1:${PORT}`)
+const THRESHOLD = Number(arg('--threshold', process.env.EVAL_THRESHOLD ?? '0.7'))
+const START_CMD = process.env.EVAL_START_CMD ?? 'pnpm start'
+
+async function loadScenarios() {
+  const raw = await readFile(resolve(ROOT, 'tests/eval/scenarios.json'), 'utf8')
+  return JSON.parse(raw)
+}
+
+async function waitForReady(baseUrl, timeoutMs = 30_000) {
+  const deadline = Date.now() + timeoutMs
+  while (Date.now() < deadline) {
+    try {
+      const res = await fetch(`${baseUrl}/health`, { signal: AbortSignal.timeout(1500) })
+      if (res.ok) return true
+    } catch { /* retry */ }
+    await new Promise((r) => setTimeout(r, 250))
+  }
+  return false
+}
+
+function shQuote(s) {
+  return `'${String(s).replace(/'/g, `'\\''`)}'`
+}
+
+// Translate a scenarios.json entry into a shell command that exits 0 on
+// assertion-pass and non-zero on fail. Keeping the assertion shape small and
+// inspectable so users can edit scenarios.json without touching this file.
+function buildTestCommand(scenario, baseUrl) {
+  const path = scenario.path ?? '/'
+  const url = `${baseUrl}${path}`
+  const checks = []
+  const expect = scenario.assert ?? {}
+  const curlBase = scenario.kind === 'http-post'
+    ? `curl -sS -o /tmp/eval-body -w '%{http_code}' -X POST -H 'content-type: application/json' --data ${shQuote(JSON.stringify(scenario.body ?? {}))} ${shQuote(url)}`
+    : `curl -sS -o /tmp/eval-body -w '%{http_code}' ${shQuote(url)}`
+  checks.push(`status=$(${curlBase})`)
+  if (expect.status !== undefined) {
+    checks.push(`test "$status" = "${expect.status}" || { echo "status $status != ${expect.status}"; exit 1; }`)
+  }
+  if (Array.isArray(expect.statusIn)) {
+    const pattern = expect.statusIn.map((s) => `"$status" = "${s}"`).join(' -o ')
+    checks.push(`test ${pattern} || { echo "status $status not in ${expect.statusIn.join(',')}"; exit 1; }`)
+  }
+  if (expect.requireJson) {
+    checks.push(`jq -e . /tmp/eval-body > /dev/null || { echo "response not JSON"; exit 1; }`)
+  }
+  if (expect.jsonShape) {
+    for (const [key, types] of Object.entries(expect.jsonShape)) {
+      const typesArr = Array.isArray(types) ? types : [types]
+      const typeChecks = typesArr.map((t) => {
+        if (t === 'null') return `(. == null)`
+        if (t === 'undefined') return `(has(${shQuote(key)}) | not)`
+        if (t === 'array') return `(type == "array")`
+        return `(type == ${shQuote(t)})`
+      }).join(' or ')
+      checks.push(
+        `jq -e ${shQuote(`.${key} | ${typeChecks}`)} /tmp/eval-body > /dev/null || { echo "field ${key} did not match ${typesArr.join('|')}"; exit 1; }`,
+      )
+    }
+  }
+  if (expect.minResponseChars !== undefined) {
+    checks.push(`test $(wc -c < /tmp/eval-body) -ge ${expect.minResponseChars} || { echo "response too short"; exit 1; }`)
+  }
+  return checks.join(' && ') + ' && echo "ok"'
+}
+
+async function runAgentSubprocess() {
+  const [cmd, ...args] = START_CMD.split(' ')
+  const env = { ...process.env, PORT: String(PORT) }
+  const child = spawn(cmd, args, { cwd: ROOT, env, stdio: ['ignore', 'pipe', 'pipe'] })
+  let stderr = ''
+  child.stderr.on('data', (d) => { stderr += String(d) })
+  return { child, getStderr: () => stderr }
+}
+
+async function main() {
+  const { scenarios } = await loadScenarios()
+  let agentProc = null
+  try {
+    if (!NO_SPAWN) {
+      agentProc = await runAgentSubprocess()
+      const ready = await waitForReady(BASE)
+      if (!ready) {
+        console.error(`[run-eval] agent did not respond on ${BASE} within 30s`)
+        console.error(agentProc.getStderr().slice(-1200))
+        process.exit(2)
+      }
+    }
+
+    const store = new InMemoryTraceStore()
+    const driver = new SubprocessSandboxDriver({ cwd: ROOT })
+    const results = []
+    for (const s of scenarios) {
+      const testCommand = buildTestCommand(s, BASE)
+      const scenario = {
+        id: s.id,
+        description: s.description,
+        harness: {
+          testCommand,
+          cwd: ROOT,
+          timeoutMs: s.timeoutMs ?? 15_000,
+        },
+        tags: { weight: String(s.weight ?? 1) },
+      }
+      const res = await runTestGradedScenario(scenario, store, { driver })
+      results.push({
+        id: s.id,
+        description: s.description ?? null,
+        passed: res.pass,
+        score: res.score,
+        failureClass: res.failureClass,
+        weight: s.weight ?? 1,
+        exitCode: res.harness.test?.exitCode ?? null,
+        stderr: (res.harness.test?.stderr ?? '').slice(-400),
+        runId: res.runId,
+      })
+      const mark = res.pass ? '✓' : '✗'
+      const reason = res.pass
+        ? 'ok'
+        : (res.harness.test?.stdout?.trim() || res.harness.test?.stderr?.trim() || res.failureClass || 'fail')
+      console.log(`  ${mark} ${s.id} — ${reason}`)
+    }
+
+    const totalWeight = results.reduce((a, r) => a + r.weight, 0) || 1
+    const weighted = results.reduce((a, r) => a + r.score * r.weight, 0)
+    const aggregate = weighted / totalWeight
+    const scorecard = {
+      timestamp: new Date().toISOString(),
+      baseUrl: BASE,
+      aggregate,
+      passCount: results.filter((r) => r.passed).length,
+      totalCount: results.length,
+      threshold: THRESHOLD,
+      results,
+      tracedRuns: (await store.listRuns?.()) ?? results.map((r) => r.runId),
+    }
+
+    const outDir = resolve(ROOT, '.evolve/eval')
+    if (!existsSync(outDir)) await mkdir(outDir, { recursive: true })
+    await writeFile(resolve(outDir, 'latest.json'), JSON.stringify(scorecard, null, 2))
+    await writeFile(
+      resolve(outDir, `${scorecard.timestamp.replace(/[:.]/g, '-')}.json`),
+      JSON.stringify(scorecard, null, 2),
+    )
+    console.log(`\naggregate=${aggregate.toFixed(3)} pass=${scorecard.passCount}/${scorecard.totalCount} threshold=${THRESHOLD}`)
+    process.exitCode = aggregate < THRESHOLD ? 1 : 0
+  } finally {
+    if (agentProc?.child && !agentProc.child.killed) {
+      try { agentProc.child.kill('SIGTERM') } catch {}
+    }
+  }
+}
+
+main().catch((err) => {
+  console.error('[run-eval] fatal:', err)
+  process.exit(2)
+})

package/registry/layers/capability/agent-eval/files/tests/eval/scenarios.json

@@ -0,0 +1,47 @@
+{
+  "version": 1,
+  "description": "Starter eval scenarios. Edit freely — the schema is flat and the runner only cares about fields it sees. Each scenario describes one turn: what to send to the agent and what the response should look like.",
+  "scenarios": [
+    {
+      "id": "smoke/health-ok",
+      "description": "Service is up and returns JSON on /health.",
+      "kind": "http-get",
+      "path": "/health",
+      "assert": {
+        "status": 200,
+        "jsonShape": { "status": ["string"] }
+      },
+      "weight": 1
+    },
+    {
+      "id": "behavior/handles-simple-task",
+      "description": "Agent accepts a plain-language task and returns a non-empty draft or reply.",
+      "kind": "http-post",
+      "path": "/run",
+      "body": { "task": "Summarize the benefits of evaluating agents continuously." },
+      "assert": {
+        "status": 200,
+        "jsonShape": { "draft": ["string", "null"], "messages": ["array", "undefined"] },
+        "minResponseChars": 40
+      },
+      "fallbackPath": "/",
+      "weight": 2
+    },
+    {
+      "id": "behavior/rejects-missing-task",
+      "description": "Agent input validation — missing task field returns 4xx, not 500 or silent success.",
+      "kind": "http-post",
+      "path": "/run",
+      "body": {},
+      "assert": {
+        "statusIn": [400, 422],
+        "requireJson": true
+      },
+      "fallbackPath": "/",
+      "fallbackAssert": {
+        "statusIn": [200, 400, 404, 405]
+      },
+      "weight": 1
+    }
+  ]
+}

package/registry/layers/capability/agent-eval/manifest.json

@@ -0,0 +1,73 @@
+{
+  "id": "agent-eval",
+  "description": "Ships a reproducible agent-eval harness into the scaffold: starter scenarios, a deterministic + optional LLM-judge runner that talks to the agent over HTTP, a baseline/regression workflow, and a CI gate. Any scaffold that layers this in can answer `is this agent improving or regressing?` from minute zero, no separate eval repo to bootstrap.",
+  "appliesTo": [
+    "agent-service-ts",
+    "agent-swarm-ts",
+    "multimodal-agent",
+    "voice-first-agent",
+    "vision-first-agent"
+  ],
+  "defaults": {
+    "evalPort": "3100",
+    "evalThreshold": "0.7"
+  },
+  "packageDeps": {
+    "dependencies": {
+      "@tangle-network/agent-eval": "^0.7.0"
+    }
+  },
+  "files": [
+    {
+      "source": "files/tests/eval/scenarios.json",
+      "target": "tests/eval/scenarios.json"
+    },
+    {
+      "source": "files/tests/eval/run-eval.mjs",
+      "target": "tests/eval/run-eval.mjs"
+    },
+    {
+      "source": "files/tests/eval/judge.mjs",
+      "target": "tests/eval/judge.mjs"
+    },
+    {
+      "source": "files/tests/eval/README.md",
+      "target": "tests/eval/README.md"
+    },
+    {
+      "source": "files/.github/workflows/eval.yml",
+      "target": ".github/workflows/eval.yml"
+    },
+    {
+      "source": "files/scripts/eval-baseline.mjs",
+      "target": "scripts/eval-baseline.mjs"
+    }
+  ],
+  "contextHints": {
+    "commands": [
+      "node tests/eval/run-eval.mjs",
+      "node scripts/eval-baseline.mjs --write"
+    ],
+    "extensionPoints": [
+      "tests/eval/scenarios.json",
+      "tests/eval/judge.mjs"
+    ]
+  },
+  "keywords": [
+    "agent eval",
+    "agent evaluation",
+    "eval harness",
+    "llm judge",
+    "llm as judge",
+    "quality gate",
+    "agent quality",
+    "scoring pipeline",
+    "benchmark agent",
+    "eval integrated",
+    "measurable agent"
+  ],
+  "tieredKeywords": {
+    "tier1": ["agent eval", "eval harness", "quality gate"],
+    "tier2": ["llm judge", "scoring pipeline", "benchmark agent", "eval integrated"]
+  }
+}

package/registry/layers/capability/agent-multi-agent/manifest.json

@@ -1,6 +1,6 @@
 {
   "id": "agent-multi-agent",
-  "description": "Adds supervisor/worker multi-agent orchestration with routing and handoff protocols.",
+  "description": "In-process sub-agent tool-routing for single agent-service starters — the main agent delegates to specialist sub-agents exposed as tools. For full graph-based swarm orchestration, use family:agent-swarm-ts instead.",
   "appliesTo": [
     "agent-service-ts",
     "agent-service-py",
@@ -27,13 +27,13 @@
     ]
   },
   "keywords": [
-    "multi-agent",
-    "multi agent",
-    "supervisor agent",
-    "agent orchestration",
-    "agent team",
-    "crew",
-    "swarm",
-    "agent hierarchy"
+    "sub-agent tool",
+    "sub-agent delegation",
+    "parallel tool use",
+    "agent-as-tool",
+    "agent hierarchy",
+    "nested agent",
+    "tool-routing agent",
+    "agent with sub-agents"
   ]
 }

package/registry/layers/capability/ai-chat-ui/manifest.json

@@ -25,7 +25,9 @@
       "chat-data.json"
     ]
   },
-  "capabilityRequires": ["layout-chat"],
+  "capabilityRequires": [
+    "layout-chat"
+  ],
   "keywords": [
     "chat interface",
     "chat ui",
@@ -61,5 +63,114 @@
       "Server-Sent Events for streaming",
       "Markdown rendering"
     ]
+  },
+  "packageDeps": {
+    "dependencies": {
+      "ai": "^4.0.0",
+      "@ai-sdk/react": "^1.0.0"
+    }
+  },
+  "tieredKeywords": {
+    "archetypes": [
+      "ai app",
+      "ai tool",
+      "ai platform",
+      "ai assistant",
+      "ai agent",
+      "ai bot",
+      "ai advisor",
+      "ai tutor",
+      "ai companion",
+      "ai writer",
+      "ai scheduler",
+      "ai analyzer",
+      "ai optimizer",
+      "ai planner",
+      "ai generator",
+      "ai helper",
+      "ai reviewer",
+      "ai builder",
+      "ai engine",
+      "ai system",
+      "ai pipeline",
+      "ai workflow",
+      "ai manager",
+      "ai screener",
+      "ai screening",
+      "ai coach",
+      "ai copilot",
+      "ai feature",
+      "ai cooking",
+      "ai personal",
+      "ai language",
+      "ai voice",
+      "ai travel",
+      "ai meal",
+      "ai interior",
+      "ai code",
+      "ai recipe",
+      "ai resume",
+      "ai social",
+      "ai customer",
+      "ai legal",
+      "ai medical",
+      "ai homework",
+      "ai newsletter",
+      "ai podcast",
+      "ai video",
+      "ai property",
+      "ai content",
+      "ai data",
+      "ai recruit",
+      "ai symptom",
+      "ai image",
+      "ai photo",
+      "ai audio",
+      "ai chat",
+      "ai email",
+      "ai search",
+      "ai-powered",
+      "ai-driven",
+      "generative ai",
+      "artificial intelligence",
+      "ai suggests",
+      "ai turns",
+      "ai generates",
+      "ai highlights",
+      "ai writes",
+      "ai answers",
+      "ai analyzes",
+      "ai estimates",
+      "ai categor",
+      "ai identif",
+      "ai creat",
+      "ai cuts",
+      "ai tailors",
+      "ai adapts",
+      "ai screens",
+      "ai extracts",
+      "ai explains",
+      "ai reads",
+      "ai understands",
+      "ai processes",
+      "ai translates",
+      "ai summar",
+      "ai detects",
+      "ai recommends",
+      "ai scores",
+      "ai that",
+      "ai to ",
+      "ai which",
+      "ai for",
+      "an ai ",
+      "a ai ",
+      "transcribes",
+      "transcription",
+      "gives me a summary",
+      "summarizes",
+      "auto-summar",
+      "automatically generates",
+      "automatically cuts"
+    ]
   }
 }