deep-dive

Deep Dive

User-invokable wrapper around the talent-scout:deep-dive agent. Resolves a candidate name to an id, ensures the candidate is enriched to the deep-dive minimum, and dispatches the agent. Returns the agent's thesis summary.

Data directory: ~/.talent-scout/

Input: A candidate name from the user message (e.g. "deep-dive Alice Cohen", "investigate Bob Levi", "tell me more about Carol").

Output: The deep-dive agent's compact result — the candidate's name and a 2–3 sentence thesis summary grounded in the user's thesis.

Why this skill exists: The deep-dive agent is a subagent dispatched by orchestrator and scout — it expects a candidate id, not a name, and assumes enrichment is already done. This skill closes the gap so the user can target a specific person by name.

Dependencies

• Scout MCP server — read_meta with name "candidates_index.json" — name → id resolution
• Scout MCP server — read_candidate — to inspect enrichment state
• Subagent — talent-scout:enrich (deep-dive mode) — fills OSINT sources to the deep-dive minimum
• Subagent — talent-scout:deep-dive (Sonnet) — synthesizes the report and investment thesis
• Sibling skill — talent-scout:scout — used to ingest a candidate not yet in the pipeline
• Reference: docs/scoring-reference.md — tier and dimension definitions

---

Procedure

Step 1: Parse the candidate name

Extract the candidate's name from the user's message. Strip leading verbs ("deep-dive", "investigate", "look more carefully at", "tell me more about", "who is"). What remains is the name query — may be a full name, a first name, or a partial.

If you cannot identify a name (the request is generic or ambiguous), stop and ask the user who they want to deep-dive.

Step 2: Resolve the name to a candidate id

Call read_meta with name: "candidates_index.json". Search entries[] for matches against the name query — case-insensitive substring on entry.name. Also accept an exact match on entry.id (the LinkedIn slug) when the user pastes one.

Branch on match count:

• Exactly one match: Use that entry.id. Briefly confirm to the user — e.g. "Found Eli Cohen ({entry.current_role}, {entry.geo}). Starting deep-dive."

• Multiple matches: Present a numbered list with name, current role, tier, and geo for each. Ask the user to pick a number. Do not proceed until they answer.

• Zero matches: The candidate isn't in the pipeline yet. Present two options:

  1. Ingest first — invoke the scout skill with the name as a target: Skill(skill: "talent-scout:scout", args: "Find and ingest {name}"). Wait for it to surface a candidate, then re-run this skill.
  2. Cancel — abort if the user doesn't want to spend API credits on ingestion.

  Do NOT auto-ingest without explicit user confirmation. Ingestion costs LinkdAPI credits and may surface a different person than intended.

Step 3: Read the candidate record

Call read_candidate({id}). Inspect:

• enrichment.sources_checked — how many OSINT sources have been filled
• scores — whether scout-level assessment has happened
• stage — current pipeline stage (new, reviewed, researched, contacted, archived)
• deep_dive — whether a deep-dive report already exists

If deep_dive.report_path is already set and stage is researched or later, surface that to the user — "{name} already has a deep-dive report from {deep_dive.completed_at}. Re-run anyway?" Wait for confirmation before proceeding.

Step 4: Ensure deep-dive-level enrichment

The deep-dive agent gates on osint_sources_checked >= profile.policies.require_osint_minimum_for_deep_dive (typically 6). If the candidate is below that minimum, dispatch the enrich agent in deep-dive mode:

Agent(subagent_type: "talent-scout:enrich", prompt: "Enrich candidate '{id}' in deep-dive mode")

The enrich agent reads the user's thesis to drive query formulation, fills any unchecked sources, and persists findings. Wait for it to return before continuing.

If enrichment returns {ok: false, code: ...}, surface the failure and stop — don't run the deep-dive against incomplete OSINT.

Step 5: Dispatch the deep-dive agent

After enrichment completes (or was already sufficient), dispatch the deep-dive agent. The model: "sonnet" is required — assess and deep-dive agents always run on Sonnet for quality.

Agent(subagent_type: "talent-scout:deep-dive", model: "sonnet", prompt: "Deep dive candidate '{id}'")

The agent reads the candidate record, runs lookup_connections and get_similar_profiles, writes the report to data/candidates/{id}/deep-dive.md via save_report, persists structured fields via update_candidate, and returns a compact result.

If the agent returns {ok: false, code: ...}, surface the failure and stop.

Step 6: Present the result

Show the user a concise summary:

• Candidate: name, current role, geo
• Tier: from candidates_index (or note "not yet scored" if scout-level assessment is missing)
• Thesis summary: the 2–3 sentence summary from the agent
• Report location: data/candidates/{id}/deep-dive.md — the user can open it from the dashboard

Do NOT paste the full report text. The agent already persisted it; the user can read it on demand.

---

Failure handling

• Name unparseable: Ask the user who they meant.
• Multiple matches: Present numbered list, wait for selection.
• Zero matches: Offer scout-skill ingestion or cancellation. Never auto-ingest.
• Enrich agent failed: Stop and surface the failure code. The candidate's last_failure field carries the detail; the orchestrator's next session will retry.
• Deep-dive agent failed: Stop and surface the failure code. Same last_failure mechanic applies.
• Already deep-dived: Confirm before re-running.