@hailer/mcp 1.2.0 → 1.3.9

package/scripts/build-public-chat-knowledge.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+"""Compile prepared chunks under prepared-docs/HailerPublic/ into a single
+TypeScript module that exports the full knowledge corpus as a string.
+
+Run from the repo root:
+
+    python3 scripts/build-public-chat-knowledge.py
+
+Re-run whenever you edit any prepared-docs/HailerPublic/**/*.json file.
+"""
+import json
+import glob
+import os
+import sys
+
+REPO_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+SOURCE_GLOB = os.path.join(REPO_ROOT, "prepared-docs", "HailerPublic", "**", "*.json")
+OUTPUT_TS = os.path.join(REPO_ROOT, "src", "public-chat", "knowledge.ts")
+
+SCOPE_TITLES = {
+    "product": "Product & UI",
+    "developer": "Developer & MCP",
+    "legal": "Legal & Privacy",
+}
+TOPIC_TITLES = {
+    "overview": "Overview",
+    "ui-guide": "UI Guide",
+    "product-description": "Product Description",
+    "faq": "Frequently Asked Questions",
+    "mcp-server": "MCP Server",
+    "apps-and-marketplace": "Apps & Marketplace",
+    "getting-started": "Getting Started",
+    "privacy-policy": "Privacy Policy",
+}
+
+
+def main() -> int:
+    chunks_by_scope_topic: dict = {}
+    for path in sorted(glob.glob(SOURCE_GLOB, recursive=True)):
+        with open(path) as f:
+            chunks = json.load(f)
+        for c in chunks:
+            chunks_by_scope_topic.setdefault(c["scope"], {}).setdefault(c["topic"], []).append(c)
+
+    for scope_map in chunks_by_scope_topic.values():
+        for topic_chunks in scope_map.values():
+            topic_chunks.sort(key=lambda c: c["chunk_index"])
+
+    parts = [
+        "# Hailer Knowledge Base",
+        "",
+        (
+            "This is the curated, public-safe knowledge corpus that the public chatbot "
+            "uses to answer questions about Hailer. It covers product concepts, the user "
+            "interface, the MCP server, app development, and getting started."
+        ),
+        "",
+    ]
+
+    for scope in sorted(chunks_by_scope_topic.keys()):
+        parts.append(f"## {SCOPE_TITLES.get(scope, scope)}")
+        parts.append("")
+        for topic in sorted(chunks_by_scope_topic[scope].keys()):
+            parts.append(f"### {TOPIC_TITLES.get(topic, topic)}")
+            parts.append("")
+            for c in chunks_by_scope_topic[scope][topic]:
+                parts.append(f"#### {c['title']}")
+                parts.append("")
+                parts.append(c["content"])
+                parts.append("")
+
+    corpus = "\n".join(parts)
+
+    escaped = corpus.replace("\\", "\\\\").replace("`", "\\`").replace("${", "\\${")
+    total_chunks = sum(len(t) for s in chunks_by_scope_topic.values() for t in s.values())
+    scopes = ", ".join(sorted(chunks_by_scope_topic.keys()))
+
+    ts = (
+        "// AUTO-GENERATED from prepared-docs/HailerPublic/ — do not edit by hand.\n"
+        "// Regenerate via: python3 scripts/build-public-chat-knowledge.py\n"
+        "//\n"
+        f"// Source chunks: {total_chunks}\n"
+        f"// Scopes: {scopes}\n"
+        "\n"
+        f"export const HAILER_KNOWLEDGE_CORPUS = `{escaped}`;\n"
+        "\n"
+        "export const HAILER_KNOWLEDGE_BYTES = HAILER_KNOWLEDGE_CORPUS.length;\n"
+    )
+
+    os.makedirs(os.path.dirname(OUTPUT_TS), exist_ok=True)
+    with open(OUTPUT_TS, "w") as f:
+        f.write(ts)
+
+    print(f"Wrote {OUTPUT_TS}")
+    print(f"Corpus size: {len(corpus):,} chars (~{len(corpus) // 4:,} tokens)")
+    print(f"Total chunks: {total_chunks}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/smoke-public-chat-live.ts

@@ -0,0 +1,148 @@
+/**
+ * Live-LLM smoke test for the public-chat bot. Fires a small set of canned
+ * prompts at the real model with the production system prompt and reports
+ * which bot-action types showed up in the responses.
+ *
+ *   ANTHROPIC_API_KEY=... npx tsx scripts/smoke-public-chat-live.ts
+ *
+ * The script is OPTIONAL — it costs real API tokens and is non-deterministic.
+ * Run it before deploying significant prompt or corpus changes. The regular
+ * `smoke-public-chat.ts` covers everything that doesn't need a live model.
+ *
+ * The script does NOT exit non-zero on a missing action — the LLM is allowed
+ * to be cautious. It exits non-zero only on transport errors. Treat the report
+ * as a coverage signal: if all five action types reliably surface, the protocol
+ * is being honoured. If one or more are repeatedly silent across runs, the
+ * persona is probably under-specifying it or the model is dropping it.
+ */
+
+import Anthropic from '@anthropic-ai/sdk';
+import { buildPublicChatSystem } from '../src/public-chat/system-prompt';
+
+// Minimal extractor — mirrors the frontend's bot-action-parser regex pair
+// (BOT_ACTION_REGEX and INVOKE_FORM_REGEX from
+// hailer-frontend-2/.../bot-action-parser.ts). Inlined to keep this script
+// repo-local with no extra deps.
+const ACTION_TYPES = '(navigate|highlight|point|presentation|slide)';
+const TAG_REGEXES = [
+    new RegExp(`<bot-action\\s+type="${ACTION_TYPES}"\\s+target="([^"]+)"`, 'g'),
+    new RegExp(`<invoke\\s+name="bot_action"\\s+type="${ACTION_TYPES}"\\s+target="([^"]+)"`, 'g'),
+];
+
+function extractActionTypes(text: string): Set<string> {
+    const found = new Set<string>();
+    for (const re of TAG_REGEXES) {
+        re.lastIndex = 0;
+        let m: RegExpExecArray | null;
+        while ((m = re.exec(text)) !== null) {
+            found.add(m[1]!);
+        }
+    }
+    return found;
+}
+
+const MODEL = 'claude-haiku-4-5-20251001';
+const MAX_TOKENS = 600;
+
+interface Probe {
+    label: string;
+    prompt: string;
+    /** Action types we'd expect to see at least one of in the reply. */
+    expect: Array<'navigate' | 'highlight' | 'point' | 'presentation' | 'slide'>;
+}
+
+const PROBES: Probe[] = [
+    {
+        label: 'tour invitation triggers a guided tour',
+        prompt: "I'm a developer evaluating Hailer for our team. Give me a quick walk-through of how this would feel.",
+        expect: ['navigate', 'point'],
+    },
+    {
+        label: 'explicit "show me X" triggers navigate or highlight',
+        prompt: 'Where do I see the calendar?',
+        expect: ['navigate', 'highlight'],
+    },
+    {
+        label: 'overview ask triggers the presentation',
+        prompt: "What is Hailer? Give me the elevator pitch — I want the big picture.",
+        expect: ['presentation'],
+    },
+    {
+        label: 'concept question triggers an inline slide chip',
+        prompt: 'Can you explain what a workflow is in Hailer?',
+        expect: ['slide'],
+    },
+];
+
+async function main(): Promise<void> {
+    const apiKey = process.env['ANTHROPIC_API_KEY'];
+    if (!apiKey) {
+        console.error('ANTHROPIC_API_KEY env var is required for the live smoke.');
+        process.exit(2);
+    }
+    const anthropic = new Anthropic({ apiKey });
+
+    const system = buildPublicChatSystem();
+
+    let probesRun = 0;
+    let expectedActionsSatisfied = 0;
+    let expectedActionsTotal = 0;
+    const misses: Array<{ probe: string; missing: string[] }> = [];
+
+    for (const probe of PROBES) {
+        probesRun += 1;
+        process.stdout.write(`\n• ${probe.label}\n  prompt: ${probe.prompt}\n`);
+        let fullText = '';
+        try {
+            const response = await anthropic.messages.create({
+                model: MODEL,
+                max_tokens: MAX_TOKENS,
+                temperature: 0.3,
+                system,
+                messages: [{ role: 'user', content: probe.prompt }],
+            });
+            for (const block of response.content) {
+                if (block.type === 'text') fullText += block.text;
+            }
+        } catch (err) {
+            console.error(`  TRANSPORT ERROR: ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(1);
+        }
+
+        const surfaced = extractActionTypes(fullText);
+
+        const missing: string[] = [];
+        for (const exp of probe.expect) {
+            expectedActionsTotal += 1;
+            if (surfaced.has(exp)) {
+                expectedActionsSatisfied += 1;
+            } else {
+                missing.push(exp);
+            }
+        }
+        console.log(`  surfaced: ${Array.from(surfaced).join(', ') || '(none)'}`);
+        console.log(`  expected: ${probe.expect.join(', ')}`);
+        if (missing.length > 0) {
+            misses.push({ probe: probe.label, missing });
+            console.log(`  MISSING: ${missing.join(', ')}`);
+        }
+    }
+
+    console.log(
+        `\n${expectedActionsSatisfied}/${expectedActionsTotal} expected action types surfaced across ${probesRun} probes`
+    );
+    if (misses.length > 0) {
+        console.log('\nMisses worth investigating if they repeat across runs:');
+        for (const m of misses) {
+            console.log(`  - "${m.probe}" missing: ${m.missing.join(', ')}`);
+        }
+    }
+    // Don't fail the run on missing actions — the LLM may legitimately reply in
+    // plain prose. Transport errors above are the only hard failure.
+    process.exit(0);
+}
+
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/scripts/smoke-public-chat.ts

@@ -0,0 +1,110 @@
+/**
+ * Smoke test for the public-chat module — exercises the pieces that don't
+ * need a live Anthropic API key.
+ *
+ *   npx tsx scripts/smoke-public-chat.ts
+ */
+
+import assert from 'node:assert/strict';
+import { buildPublicChatSystem, KNOWLEDGE_BYTES } from '../src/public-chat/system-prompt';
+import { checkRate, _resetForTests } from '../src/public-chat/rate-limit';
+import { HAILER_KNOWLEDGE_CORPUS } from '../src/public-chat/knowledge';
+
+let ran = 0;
+let failed = 0;
+
+function check(name: string, fn: () => void): void {
+  ran += 1;
+  try {
+    fn();
+    console.log(`  ok ${name}`);
+  } catch (err) {
+    failed += 1;
+    console.log(`  FAIL ${name}`);
+    console.error(err);
+  }
+}
+
+console.log('public-chat smoke');
+
+console.log('\nknowledge corpus:');
+check('compiled and non-trivial', () => {
+  assert.ok(HAILER_KNOWLEDGE_CORPUS.length > 10_000, 'too small');
+  assert.ok(HAILER_KNOWLEDGE_CORPUS.length < 200_000, 'too large');
+  assert.equal(KNOWLEDGE_BYTES, HAILER_KNOWLEDGE_CORPUS.length);
+});
+check('mentions all five top-level topics', () => {
+  const lower = HAILER_KNOWLEDGE_CORPUS.toLowerCase();
+  for (const term of ['overview', 'ui guide', 'mcp server', 'apps & marketplace', 'getting started']) {
+    assert.ok(lower.includes(term), `missing: ${term}`);
+  }
+});
+check('omits internal infra/compliance bait words', () => {
+  const lower = HAILER_KNOWLEDGE_CORPUS.toLowerCase();
+  for (const banned of ['client_configs={', 'infra/', 'hailer-frontend-2/']) {
+    assert.ok(!lower.includes(banned), `should not contain: ${banned}`);
+  }
+});
+
+console.log('\nbuildPublicChatSystem:');
+check('returns two cached text blocks', () => {
+  const blocks = buildPublicChatSystem();
+  assert.equal(blocks.length, 2);
+  for (const block of blocks) {
+    assert.equal(block.type, 'text');
+    assert.deepEqual(block.cache_control, { type: 'ephemeral' });
+    assert.ok(block.text.length > 0);
+  }
+});
+check('persona block describes role and bot-action protocol', () => {
+  const [persona] = buildPublicChatSystem();
+  assert.match(persona.text, /Hailer Helper/i);
+  assert.match(persona.text, /bot-action/i);
+  assert.match(persona.text, /navigate/i);
+  assert.match(persona.text, /highlight/i);
+});
+check('persona documents all five bot-action types and shows their canonical form', () => {
+  // If any of these regress (someone deletes a section, renames a type, etc.)
+  // the model loses the affordance and the demo silently degrades. Cheap to
+  // assert on every smoke run.
+  const [persona] = buildPublicChatSystem();
+  for (const type of ['navigate', 'highlight', 'point', 'presentation', 'slide']) {
+    const re = new RegExp(`<bot-action\\s+type="${type}"`, 'i');
+    assert.match(persona.text, re, `persona missing canonical form for type="${type}"`);
+  }
+});
+check('persona explicitly acknowledges the always-visible Continue button', () => {
+  // Was once the other way around — persona told the bot to "surface" the CTA
+  // even though the button is always visible. Lock the corrected wording in.
+  const [persona] = buildPublicChatSystem();
+  assert.match(persona.text, /persistently visible|always visible/i);
+});
+check('knowledge block carries the full corpus', () => {
+  const [, knowledge] = buildPublicChatSystem();
+  assert.ok(knowledge.text.includes(HAILER_KNOWLEDGE_CORPUS));
+});
+
+console.log('\ncheckRate:');
+_resetForTests();
+check('allows the first 30 requests from a single IP', () => {
+  for (let i = 0; i < 30; i++) {
+    const r = checkRate('1.2.3.4');
+    assert.equal(r.ok, true, `request ${i + 1} should be allowed`);
+    assert.equal(r.remaining, 30 - 1 - i);
+  }
+});
+check('rejects the 31st request with retry-after', () => {
+  const blocked = checkRate('1.2.3.4');
+  assert.equal(blocked.ok, false);
+  assert.equal(blocked.remaining, 0);
+  assert.ok((blocked.retryAfterSec ?? 0) > 0);
+});
+_resetForTests();
+check('keeps independent counters per IP', () => {
+  for (let i = 0; i < 30; i++) checkRate('9.9.9.9');
+  assert.equal(checkRate('9.9.9.9').ok, false);
+  assert.equal(checkRate('1.1.1.1').ok, true);
+});
+
+console.log(`\n${ran - failed}/${ran} passed${failed === 0 ? '' : `, ${failed} failed`}`);
+process.exit(failed === 0 ? 0 : 1);

package/.claude/CLAUDE.md

@@ -1,126 +0,0 @@
-# Hailer SDK + MCP Project
-
-## The One Rule
-
-**If it can be done locally, do it locally. MCP tools are ONLY for things that require a server call.**
-
-This project has `workspace/` files managed by `@hailer/sdk`. These files ARE the source of truth for all workflow configuration. The MCP server provides tools for runtime operations that require talking to Hailer's API.
-
-## What Goes Where
-
-| Need | Do this | NEVER this |
-|------|---------|------------|
-| **Find workflow/field/phase IDs** | Read `workspace/enums.ts` | ~~`list_workflows_minimal`~~, ~~`get_workflow_schema`~~, ~~`list_workflow_phases`~~ |
-| **See field types, labels, options** | Read `workspace/<Name>_<id>/fields.ts` | ~~`get_workflow_schema`~~ |
-| **See phases** | Read `workspace/<Name>_<id>/phases.ts` | ~~`list_workflow_phases`~~ |
-| **See all workflows** | Read `workspace/workflows.ts` | ~~`list_workflows`~~ |
-| **Create/modify fields** | Edit `fields.ts` → `npm run fields-push:force` | ~~`update_workflow_field`~~ |
-| **Create/modify phases** | Edit `phases.ts` → `npm run phases-push:force` | ~~`update_workflow_phase`~~ |
-| **Create/modify workflows** | Edit `workflows.ts` → `npm run workflows-sync:force` | ~~`install_workflow`~~ |
-| **Create/modify teams** | Edit `teams.ts` → `npm run teams-push:force` | — |
-| **Create/modify groups** | Edit `groups.ts` → `npm run groups-push:force` | — |
-| **Create activities** | MCP `create_activity` | — |
-| **List/read activities** | MCP `list_activities`, `show_activity_by_id` | — |
-| **Update activities** | MCP `update_activity` | — |
-| **Query data** | MCP `preview_insight`, `create_insight` | — |
-| **Discussions** | MCP discussion tools | — |
-| **Activity counts** | MCP `core_init` (once per session) | — |
-| **Scaffold app** | MCP `scaffold_hailer_app` | — |
-| **Publish app** | MCP `publish_hailer_app` | — |
-
-**If you're about to call an MCP tool, ask yourself: "Is this data in workspace/ files?" If yes, read the file instead.**
-
-## How to Read workspace/ Files
-
-**Never read workspace/ files in main context** — they're large and fill context permanently.
-
-1. Spawn a **haiku sub-agent** to read the files
-2. Have it extract what you need (IDs, field types, phase names)
-3. It returns a short summary
-4. Use that summary for MCP runtime calls
-
-```
-Pattern: haiku reads workspace/ → you get IDs → MCP create_activity/list_activities
-```
-
-## Sub-Agent Rules
-
-- **Haiku:** Read files, search code, data lookups, reviews
-- **Sonnet:** Write code, build features, complex edits
-- **You (Opus):** Orchestrate, synthesize results, make decisions
-- **Skills:** Load in sub-agents only, never in main context
-- If a task takes more than ~20 lines of code, delegate to sonnet
-
-## workspace/ Structure
-
-```
-workspace/
-├── enums.ts          # ALL IDs — WorkflowIds, FieldIds, PhaseIds, etc.
-├── workflows.ts      # Workflow registry
-├── teams.ts          # Team definitions
-├── groups.ts         # Group definitions
-├── insights.ts       # Insight definitions
-└── <WorkflowName>_<id>/
-    ├── fields.ts     # Field definitions (type, label, key, options, required)
-    ├── phases.ts     # Phase definitions (name, key, isInitial, isEndpoint)
-    ├── main.ts       # Workflow config
-    └── functions/    # Function field code (if any)
-```
-
-**Refresh:** `npm run pull` syncs server → local files
-
-## SDK Push Commands (all use `:force` to avoid interactive prompts)
-
-| Command | What it does |
-|---------|-------------|
-| `npm run push:force` | Push everything |
-| `npm run fields-push:force` | Push field changes only |
-| `npm run phases-push:force` | Push phase changes only |
-| `npm run workflows-sync:force` | Sync workflow registry (create/delete) |
-| `npm run teams-push:force` | Push team changes |
-| `npm run groups-push:force` | Push group changes |
-| `npm run pull` | Pull latest from Hailer → local files |
-
-## SDK Gotchas
-
-| Gotcha | Correct | Wrong |
-|--------|---------|-------|
-| New fields | Omit `_id` — server assigns it | Adding `_id` manually |
-| After push | Always `npm run pull` to get server-assigned IDs | Assuming local IDs are final |
-| Function fields | `npm run fields-push:force` (non-force skips functionVariables) | `npm run fields-push` |
-| Enum imports | Verify after pull — identical hex suffixes can collide | Trusting auto-generated imports |
-| `linkedfrom` fields | Don't work in isolated-vm — use `<` backlink dependency | Using in function fields |
-| Function field code | Plain JavaScript only | TypeScript syntax |
-| Phase transitions | Exact string match on phase name | Guessed names |
-| Field values (MCP) | Date: Unix ms (`1730937600000`), Dropdown: exact string, ActivityLink: string ID | ISO dates, arrays, objects |
-
-## App Development
-
-| Step | How |
-|------|-----|
-| Scaffold | MCP `scaffold_hailer_app` — never copy apps |
-| Publish | MCP `publish_hailer_app` — auto icon, name, description, sharing |
-| Local dev | `npm run dev` from app directory |
-
-## Skills
-
-Load in sub-agents via Skill tool. Never in main context.
-
-| Skill | When |
-|-------|------|
-| `sdk-ws-config-skill` | Workflows, fields, phases, teams, groups |
-| `sdk-function-fields` | Calculated fields, nameFunction |
-| `sdk-activity-patterns` | Creating/updating activities via MCP |
-| `sdk-insight-queries` | SQL insight queries |
-| `hailer-app-builder` | Building Hailer apps (React/Chakra) |
-| `hailer-design-system` | Theme, colors, icons, layout |
-| `publish-hailer-app` | Publishing apps to production |
-| `testing-patterns` | Vitest/playwright tests |
-
-## Commands
-
-`/command <param>` — angle brackets = required
-
-**Essential:** `/save`, `/handoff`, `/prd`, `/autoplan`, `/ws-pull`
-
-**Squads:** `/app-squad`, `/review-squad`, `/config-squad`, `/hotfix-squad`, `/debug-squad`, `/swarm <desc>`

package/.claude/commands/app-squad.md

@@ -1,131 +0,0 @@
----
-description: Build a Hailer app with hyper-parallel component teams
-argument-hint: "app description"
-allowed-tools: Task, Bash, Read, Skill
----
-# App Squad
-
-Hyper-parallel: orchestrator does ALL prep, then spawns one agent per component with everything pre-loaded. Agents do ZERO discovery — just write code.
-
-**Goal:** $ARGUMENTS
-
-## Protocol
-
-### Step 1: Full Prep (YOU do everything — fast)
-
-**Schema discovery (MCP calls, parallel):**
-- `list_workflows_minimal` → find relevant workflows
-- `list_workflow_phases` per workflow → phase IDs/names
-- `get_workflow_schema` per workflow → field IDs/types/labels
-- `list_insights` → existing insights
-
-**Scaffold:**
-- `scaffold_hailer_app` MCP tool (NEVER copy an existing app)
-
-**Read scaffold SDK files:**
-- `src/hailer/use-app.ts` — the Zustand store, understand the API
-- `src/hailer/use-hailer.tsx` — the raw hook (if use-app isn't available)
-- `src/main.tsx` — entry point (ChakraProvider + theme)
-- Check available icons: `ls src/hailer/theme/icons/`
-
-**Load skills (YOU load, paste into prompts):**
-- Load `hailer-app-builder` skill via Skill tool
-- Load `hailer-design-system` skill via Skill tool
-- Save the content — you'll paste it into every agent prompt
-
-**Read one existing working app** for reference:
-- Pick an app from `apps/` that works, read its App.tsx
-- Extract the SDK integration patterns (how it fetches, how it reads fields)
-
-### Step 2: Define Shared Contract
-
-Write this contract — every agent gets the exact same copy:
-
-```
-## SHARED CONTRACT
-
-### Constants
-[Paste all workflow IDs, field IDs, phase IDs from schema discovery]
-
-### SDK API (from scaffold)
-[Paste the actual use-app.ts store shape — what useApp() returns]
-[Paste how to fetch: hailer.activity.list(workflowId, phaseId, { limit: 500 })]
-[Paste how fields work: activity.fields?.[fieldId] with value wrappers]
-
-### Helper Functions
-[getField, getNumField, formatValue, getRating — whatever the app needs]
-
-### Component Manifest
-[List every component: name, file path, props interface, what it renders]
-
-### Import Paths
-[Exact import paths for SDK: '../hailer/use-app', icons, theme, etc.]
-
-### Icon Paths
-[Available icons with exact import paths: '../hailer/theme/icons/HailerSearch']
-
-### SDK Patterns (from existing working app)
-[Paste the patterns that WORK — how ready/inside/outside are handled]
-[CRITICAL: Apps must render even when outside Hailer — never block on `inside`]
-
-### Skill Content
-[Paste hailer-app-builder skill content]
-[Paste hailer-design-system skill content]
-```
-
-### Step 3: Spawn ALL Agents in One Message
-
-Every agent gets the FULL shared contract. They do ZERO skill loading, ZERO file reading.
-
-Each agent prompt:
-```
-You are building ONE component of a Hailer app.
-
-[PASTE FULL SHARED CONTRACT]
-
-## Your Mission: [COMPONENT NAME]
-[What to build, what props it takes, what it renders]
-
-Return ONLY the complete TypeScript/React code. No file operations, no skill loading, no discovery.
-```
-
-Typical team:
-| Agent | Builds | Model |
-|-------|--------|-------|
-| Shell | App.tsx — nav, state, data fetching, renders children | sonnet |
-| Overview | Dashboard — stat cards, summaries, charts | sonnet |
-| List View | Table — filters, sorting, row click | sonnet |
-| Detail | Modal content — full record view | sonnet |
-| (per extra workflow) | Additional list+detail | sonnet |
-
-### Step 4: Assemble + Verify (YOU)
-
-1. Write each component to its file
-2. Delete scaffold demo components (ChartDemo, ActivityTable, etc.)
-3. Fix integration issues (import paths, prop mismatches)
-4. `npx tsc --noEmit` → fix any errors
-5. `npx vite build` → verify
-6. If < 5 errors, fix directly. If major, re-spawn failing agent with error + context.
-
-### Step 5: Report
-
-```markdown
-## App Built: [name]
-- Path: apps/[name]/
-- Components: [N] built in parallel
-- Build: PASS
-- TypeScript: 0 errors
-
-### Next Steps
-- `cd apps/[name] && npm run dev`
-- Open in Hailer iframe to test with live data
-```
-
-## Rules
-
-- NEVER copy existing apps — scaffold fresh
-- NEVER let agents load skills — you pre-load and paste
-- NEVER let agents read files — you read and paste
-- Apps must work when opened outside Hailer (show empty state, not error)
-- Include the ACTUAL SDK code in the contract, not a summary
-- Agents return code as text — you write the files