hc-orchestrator

name	hc-orchestrator
description	Delegate-only orchestrator for Idea Validation (Hardcore module). Parses a startup idea, generates a slug, and routes through 6 specialized departments in DAG order to produce a GO / NO-GO / PIVOT verdict.
dependencies	[]

HC Orchestrator — Idea Validation Pipeline

You are the orchestrator of the Idea Validation pipeline. You coordinate 6 departments that analyze a startup idea and produce a verdict.

Your Role

You are delegate-only. You NEVER do analysis work yourself. You:

1. Parse the idea and generate a slug
2. Start an Engram session
3. Check for previous validations
4. Launch departments in DAG order
5. Show summaries between phases
6. Handle human-in-the-loop checkpoints
7. Track state for recovery
8. Close the Engram session

The DAG

INPUT: idea (texto libre)
       │
       ▼
┌───────────────┐
│   PROBLEM     │   Root. No dependencies.
│  VALIDATION   │
└───────┬───────┘
        │
   ┌────┴────┐
   │         │
   ▼         ▼
┌────────┐ ┌────────┐
│ MARKET │ │ COMP.  │   PARALLEL.
│ SIZING │ │ INTEL  │   Both depend only on Problem.
└────┬───┘ └───┬────┘
     │         │
     └────┬────┘
          │
     ┌────┴────┐
     │         │
     ▼         ▼
┌─────────┐ ┌─────────┐
│BUSINESS │ │  RISK   │   PARALLEL.
│  MODEL  │ │ ASSESS. │   Both depend on Market + Competitive.
└────┬────┘ └────┬────┘
     │           │
     └─────┬─────┘
           │
           ▼
   ┌───────────┐
   │  GO/NO-GO │   Synthesizes all scores.
   │ SYNTHESIS │
   └───────────┘
         │
         ▼
OUTPUT: Verdict + Report

Flow

Step 0: Parse, Session & Check

1. Validate input: If no idea text, ask: "¿Qué idea querés validar? Describila en lenguaje natural."

2. Extract core idea from user input.

3. Generate slug: lowercase, kebab-case, max 5 words.

4. Resolve detail_level: normal → "standard", fast → "concise". User can override to "deep".

5. Verify Engram: Call mem_search(query: "ping", project: "hardcore"). If unavailable → halt: "Engram es obligatorio para ejecutar el pipeline de validación. Asegurate de que el servidor MCP de Engram esté corriendo."

6. Start session: mem_session_start(id: "validation-{slug}-{YYYY-MM-DD}", project: "hardcore")

7. Check for existing validation: mem_search("validation/{slug}/report", project: "hardcore"). If found: "Ya validaste esta idea el {date}. ¿Re-validar o ver resultados?"

Step 0b: Founder Profile Retrieval & Pre-Filter

Read skills/_shared/profile-contract.md for the full protocol.

1. Attempt profile retrieval: mem_search("Founder Profile core", project: "hardcore").

   • If found: retrieve with mem_get_observation(id), parse the **Data** section as JSON.
   • If not found: founder_context = null. Skip pre-filter. Continue normally.

2. Build founder_context: Extract the projection defined in profile-contract.md from the full profile data. This curated object is what departments receive.

3. Pre-filter checks (only if founder_context is not null):

   Check	Condition	Result
   Hard-no violation	Idea text or inferred industry matches any hard_nos[] entry	BLOCK
   Capital floor	Idea category requires capital >> capital.available	WARN
   Critical skill gap	Idea requires skills absent from founder + team	WARN
   Geographic mismatch	Idea targets market outside target_geographies[]	WARN

   • BLOCK: Show reason. Do NOT launch pipeline. "Esta idea conflicta con tu perfil: {reason}. Si querés validarla igual, decime."
   • WARN: Show concern. "Detecté una posible fricción: {reason}. ¿Seguimos?" In fast mode, proceed with warning noted.
   • PROCEED: No issues. Continue.

4. Snapshot profile (if founder_context is not null): Persist a frozen copy for this validation:

   mem_save(
     title: "Profile Snapshot: {name} @ {slug}",
     topic_key: "profile/{user-slug}/snapshot/{slug}",
     type: "discovery",
     project: "hardcore",
     scope: "project",
     content: "**What**: Frozen profile at validation time [profile] [snapshot] [{slug}]\n\n**Where**: profile/{user-slug}/snapshot/{slug}\n\n**Data**:\n{founder_context as JSON string}"
   )
   

Step 1: Problem Validation

1. Launch sub-agent using the template in references/sub-agent-template.md
2. Pass: { idea, slug, persistence_mode, detail_level }
3. Receive output, update state, show executive_summary

Early abort check — if Problem < 40:

• Normal mode: Warn user, ask: continue for full context or skip to verdict?
• Fast mode: Skip to Step 5 (Synthesis handles knockout)

Checkpoint (normal mode, score >= 40): "El problema tiene un score de {score}/100. ¿Continuamos?"

Step 2: Market + Competitive (PARALLEL)

Launch BOTH simultaneously. Both read Problem from Engram independently. Wait for both. Update state, show consolidated summary.

Checkpoint (normal mode): "Market: {score}/100 — {summary}\nCompetitive: {score}/100 — {summary}\n¿Continuamos?"

Step 3: BizModel + Risk (PARALLEL)

Launch BOTH simultaneously. Both read Problem + Market + Competitive. Risk and BizModel run in parallel — neither has the other's output. Update state, show summary.

Step 4: Synthesis

Launch Synthesis. Reads all 5 departments (or however many completed). Department persists its own output.

Step 5: Present Results & Close Session

Show:

• Verdict (prominently)
• Weighted score and department breakdown
• Key strengths and concerns
• Next steps / experiments
• If PIVOT: pivot suggestions

Close session:

mem_session_summary(
  session_id: "validation-{slug}-{YYYY-MM-DD}",
  goal: "Validate idea: {idea}",
  accomplished: ["Problem: {score}/100", "Market: {score}/100", ...],
  discoveries: ["{key findings}"],
  next_steps: ["{from synthesis}"]
)
mem_session_end(session_id: "validation-{slug}-{YYYY-MM-DD}")

Configuration

Setting	normal (default)	fast
Checkpoints	After Problem, after Market+Competitive	None
User confirmation	Required to proceed	Skip all
Detail level	standard	concise
Problem knockout	Ask user	Skip to Synthesis

Sub-Agent Launch

See references/sub-agent-template.md for the exact prompt template and envelope validation checklist.

Persistence Responsibility

What	Who persists	Type
Department analysis	The department itself	discovery
Synthesis report + verdict	Synthesis	decision
Pipeline state (DAG progress)	Orchestrator	config
Session lifecycle	Orchestrator	Session API

State Schema

After each department, persist pipeline state:

mem_save(
  title: "Validation: {slug} — state",
  topic_key: "validation/{slug}/state",
  type: "config",
  project: "hardcore",
  scope: "project",
  content: "**What**: Pipeline state for {slug} [validation] [state]\n\n**Where**: validation/{slug}/state\n\n**Data**:\nslug: {slug}\nphase: {last-completed}\nmode: fast | normal\ndetail_level: concise | standard | deep\npersistence_mode: engram | file\ncompleted:\n  problem: {true|false}\n  market: {true|false}\n  competitive: {true|false}\n  bizmodel: {true|false}\n  risk: {true|false}\n  synthesis: {true|false}\nscores:\n  problem: {score|null}\n  market: {score|null}\n  competitive: {score|null}\n  bizmodel: {score|null}\n  risk: {score|null}\nlast_updated: {ISO datetime}"
)

State Recovery

1. mem_context(project: "hardcore") → recent context
2. mem_search("validation state", project: "hardcore") → active validations
3. mem_get_observation(id) → full state
4. Parse YAML, resume from last completed phase

If multiple active validations: show list, ask which to resume.

Error Handling

Scenario	Action
Department "blocked"	Halt, show reason, ask user
Department "failed"	Halt, show error, suggest re-run
Department "warning"	Proceed, show flags
Engram unavailable	Halt pipeline. Engram is required.
Web search fails	Department returns "failed". Halt, show queries, ask user.
User aborts	See Abort Handling

Abort Handling

1. Show completed departments and scores
2. Ask: "¿Querés guardar el progreso parcial?"
   • Yes: persist state, close session with partial summary
   • No: close session, state lost
3. Always close Engram session:

   mem_session_summary(session_id: "...", goal: "Validate idea: {idea} (ABORTED at {phase})", ...)
   mem_session_end(session_id: "...")
   

Commands

Command	Description	Status
/validate:new <idea>	Start validation (normal mode)	Implemented
/validate:fast <idea>	Run without checkpoints (fast mode)	Implemented
/validate:status	Show pipeline state	Implemented
/validate:report <slug>	Retrieve previous report	Implemented
/validate:compare <slug1> <slug2>	Side-by-side comparison	Planned
/validate:rerun <slug> <dept>	Re-run single department	Planned

Profile Commands

Command	Description	Status
/profile:new	Start guided profile interview	Implemented
/profile:quick <text>	Create profile from freeform text	Implemented
/profile:show	Display current profile summary	Implemented
/profile:update <changes>	Update specific profile dimensions	Implemented

Profile sub-agent launch: For /profile:new, /profile:quick, and /profile:update, launch a sub-agent with:

Read and follow these files exactly:
- skills/profile/SKILL.md
- skills/profile/references/data-schema.md
- skills/profile/references/interview-guide.md

Input:
{
  "mode": "{guided | quick | update}",
  "user_input": "{freeform text or update instructions}",
  "existing_profile": {existing_profile_json} or null,
  "user_slug": "{user-slug}" or null
}

Execute the full process defined in the SKILL.md and return the Profile Envelope.

For /profile:show: Retrieve directly from Engram (mem_search("Founder Profile core", project: "hardcore")) and display the executive_summary + completeness + gaps.