setup

Migration Setup

On Entry

Tell the user:

Phase 1: Setup — I'll walk you through connecting to your source database, initializing the project, registering your objects, converting them to Snowflake SQL, and generating an assessment report. Once you've seen the assessment I'll ask whether you want to go on to migrating objects.

For a Snowflake source, use this instead:

Snowflake Validation Setup — I'll initialize a Snowflake-source project, configure the Snowflake target and orchestrator, and capture your validation strategy. Snowflake-source projects skip code conversion, assessment, deployment, data migration, testing setup, and the Data Exchange Worker.

Flow

Setup is driven by the setup state machine — the resolver picks the next step automatically. The flow:

1. Call progress_setup(). The response carries the following keys when relevant — fields that would otherwise be the no-op default (completed: false, blocked: false, etc.) are omitted to keep responses small:
   • next_task — id of the task the resolver landed on
   • next_skill — sub-skill path to load (omitted when the task is handled inline via next_prompt)
   • next_skill_md — when present, the full body of the skill at next_skill. Execute it directly without calling Read. Only emitted for skills small enough to inline; for larger ones (or any skill not in the inline set), next_skill is the path and you Read it normally.
   • next_prompt — present when the task is an inline question (see step 3 below)
   • then_ask — further questions to ask in the same turn, in order (see step 3)
   • planned_steps — remaining task ids in order
   • completed: true — only when the machine reached its terminal state; absence means "not done, keep looping"
   • blocked: true (+ blocked_on), errored: true (+ error_reason), committed: [...], project_initialized: false — emitted only when actionable
2. If completed is true, jump to On Completion below.
3. If next_prompt is non-null, the engine wants you to ask the user a question directly — no sub-skill load required. Surface the prompt exactly as the engine returned it via ask_user_question (multiSelect = false):
   • next_prompt.question is the question text.
   • next_prompt.options is the list of {label, value, description?} entries to render. Use label as the user-facing choice; never show value to the user.
   • If then_ask is present, ask every question in one ask_user_question call — next_prompt first, then each entry of then_ask in the order given, one question per entry, multiSelect = false on each. Don't ask them one call at a time. They are queued precisely because the machine reaches all of them whatever the user answers, so nothing you learn from one can make a later one wrong. The queue is capped so a whole run always fits in a single call; never split it.
   • Send every answer you collected in one call: progress_setup(answers={"<write_to>": "<chosen value>", ...}) — keys are each prompt's write_to, values the chosen option's value verbatim (a string, even for a number or a boolean). That records the answers and returns the next step, so for questions it replaces both the separate configure(...) call and the follow-up progress_setup(). Go to step 2 with its response.
   • A prompt whose chosen option carries then is the other case — that answer leads somewhere specific, so you can start on it in the same turn (such a prompt never has then_ask):
     • then.completed → setup is done; jump to On Completion.
     • then.skill → that is the step the answer leads to. Send the answer with progress_setup(answers={...}); its response carries next_skill_md for that very step, so execute it from there rather than Reading the file. then gives you the route early — what to tell the user, and what's coming — while the body arrives once, for the branch actually taken.
     • a then with only task → that step is already satisfied; send the answer and act on whatever the response names. If that response names the same next_task you just acted on, the step did not complete — do not run its skill again. Re-running it re-asks questions the user just answered; instead do what that skill says to do when it can't finish (e.g. progress_setup(skip="<task>")).