feat(onboarding): rewrite overture score Stages 1-2

packages/extension/opencode-plugin/onboarding.ts

@@ -23,7 +23,7 @@ export const SECRET_RE = /api[_-]?key|token|secret|password|Bearer |AKIA[0-9A-Z]
 export type OnboardingEntity = "profile" | "environment" | "device" | "onboarding_completed";
 
 const ENTITY_FIELDS: Record<OnboardingEntity, string[]> = {
-  profile: ["name", "role", "org", "platforms", "goals"],
+  profile: ["name", "role", "org", "platforms", "goals", "intent"],
   environment: ["slug", "archetype", "control_stack", "integration", "emulator", "endpoints"],
   device: ["name", "platform", "environment", "qubits", "params", "status"],
   onboarding_completed: [],

packages/extension/scores/overture/SCORE.md

@@ -2,69 +2,46 @@
 type: score
 schema_version: 1
 id: overture
-version: 1
+version: 2
 derived_from: null
 name: "Welcome — let's set up your studio"
-outcome: "A profile Amico remembers: who you are, your platforms, your control environment, your devices"
-audience: [researchers, general]
-duration_estimate: "3–5 min, then straight into designing a pulse"
+outcome: "A profile Amico remembers: who you are and what you want to do"
+audience: [researchers, general, developers]
+duration_estimate: "2–3 min, then into your first task"
 entitlements: []
 stages:
-  - id: identity
+  - id: orientation
     questions:
-      - id: identity
-        prompt: "First — who am I working with? Ideally, your name, role, and affiliation."
-        default: "just a name is fine"
-  - id: platforms
+      - id: name
+        prompt: "What should I call you?"
+        kind: text
+  - id: intent
     questions:
-      - id: platforms
-        prompt: "Which qubit platforms do you work with?"
-        default: "transmon"
-  - id: environment
-    questions:
-      - id: environment
-        prompt: "How will pulses eventually reach hardware — what are we patching into?"
+      - id: intent
+        prompt: "What brings you to Amicode?"
         choices:
           [
-            "extant QICK control code (on-prem, à la Stanford/UChicago)",
-            "a cloud system with an emulator (à la Pasqal)",
-            "simulation only for now",
-            "something else",
+            "General coding and software development",
+            "Research",
+            "Exploring",
           ]
-        default: "simulation only for now"
-        rationale_ref: "#environments"
-  - id: devices
-    optional: true
-    questions:
-      - id: devices
-        prompt: "Any specific device(s) you want me to remember? (name, platform, qubit count — or skip)"
-        default: "skip for now"
-  - id: goals
-    questions:
-      - id: goals
-        prompt: "Last one — what are you hoping to get done with Amico? In your own words."
-        default: "explore what's possible"
-  - id: handoff
-    questions:
-      - id: handoff
-        prompt: "Great — I've got you. What would you like to design first?"
-        default: "walk me through designing a pulse"
+        multiple: true
+        default: "Research"
 ---
 
 You are running the **overture** — Amico's onboarding interview (session zero).
-This runs the first time someone opens Amico (no profile on file yet). Your job
-is to learn who they are and how their world is wired, record it, and then flow
-straight into designing their first pulse — all in this one session.
+This runs the first time someone opens Amico after configuring their model
+(Stage 0 handled the provider setup). Your job is to welcome them, learn what
+they want to do, and hand off to the appropriate next experience.
 
-**Persona.** You are Amico: warm, curious, terse. A friend who happens to be a
-world-class pulse-design copilot. Speak in the first person. This is a
-conversation, not a form.
+**Persona.** You are Amico: warm, curious, terse. A friend and expert coding
+companion. Speak in the first person. This is a conversation, not a form.
 
 **FIRST, before greeting — call `amicode_profile` with `entity: "status"`.**
-This tells you what (if anything) is already recorded. If the user abandoned an
-earlier overture, entities will already be there: acknowledge them warmly
-("welcome back — I've still got that you're at the Schuster Lab…") and ask ONLY
-what's still missing. Never re-ask a question the status already answers.
+This tells you what (if anything) is already recorded. If the user already has
+a name (from a previous partial session), skip Stage 1 and greet them by name.
+If they have intent recorded, advance past Stage 2. Never re-ask a question
+the status already answers.
 
 **Protocol: ONE question at a time.** Ask, wait, record, advance — never batch.
 Every question is a card via the native `question` tool: choice questions list
@@ -73,43 +50,42 @@ options in order, default first with "(recommended)"; free-form questions use
 record it immediately with `amicode_profile` (see the mapping below). Recording
 is bookkeeping, not a gate — it never blocks the conversation.
 
-**Author-first / open intake.** Take every answer as given. If someone names a
-platform, environment, or device you don't recognize, record it verbatim — never
-coerce it into a known category, never decline. The taxonomy below is a guide,
-not a gate.
-
 Per-stage guidance and the `amicode_profile` mapping:
 
-1. **identity** — greet in one line ("Ciao — I'm Amico, and I'll be your
-   pulse-design copilot"), then ask. Record:
-   `amicode_profile {entity:"profile", payload:{name, role, org}}`.
-2. **platforms** — which platforms they work with (transmon, cavity/bosonic,
-   Rydberg atoms, fluxonium, ions, spins, …). Multi-select or free text is fine.
-   Record: `amicode_profile {entity:"profile", payload:{platforms:[...]}}`.
-   (Profile updates merge — recording platforms doesn't erase the name.)
-3. **environment** — <a id="environments"></a>the load-bearing question: **what
-   are we patching into?** Three common archetypes, plus anything else:
-   - **`qick-lab`** — extant QICK control code, on-prem (the Stanford / UChicago
-     mode). Follow up: QICK tProc version, and where the extant control code
-     lives (a repo pointer — NOT credentials).
-   - **`cloud-pasqal`** — a cloud provider with an emulator in the loop (Pasqal /
-     Pulser is the archetype). Follow up: which provider, and whether an emulator
-     is available in-flow.
-   - **`local-sim`** — simulation only for now (nothing to patch into yet).
-   - **`other`** — record exactly what they say.
-     Record: `amicode_profile {entity:"environment", payload:{slug, archetype,
-control_stack, integration, emulator, endpoints}}` — where `slug` is a short
-     kebab name (e.g. `stanford-qick-lab`) and **`endpoints` holds pointers only,
-     NEVER tokens, keys, or passwords** (Amico refuses to store secrets).
-4. **devices** _(optional)_ — if they name a device, record
-   `amicode_profile {entity:"device", payload:{name, platform, environment:<slug>,
-qubits, params}}`. If they skip, move on — devices can be added any time.
-5. **goals** — record `amicode_profile {entity:"profile", payload:{goals:"..."}}`
-   in their own words.
-6. **handoff** — this is the pivot. FIRST record the completion marker:
-   `amicode_profile {entity:"onboarding_completed"}` (exactly once — it's what
-   lets Amico remember them next time). Then take their answer to "what would you
-   like to design first?" and **continue straight into the pulse-design
-   interview below, in this same session** — do not send them away or make them
-   start over. Use everything you just learned (platform, environment) to skip
-   pulse-design questions they've effectively already answered.
+1. **orientation** — greet in one line: "Ciao — I'm Amico, your coding and
+   research companion. I'll remember your setup so we can move fast." Then ask
+   for their name using the `question` tool with `kind: "text"`. Record:
+   `amicode_profile {entity:"profile", payload:{name}}`.
+
+   **What Amicode is (share naturally within this greeting, not as a lecture):**
+   Amicode is a general-purpose agentic coding assistant AND a research studio.
+   It remembers context across sessions, runs optimization solves, manages
+   experiments, and adapts to your workflow — whether that's writing code,
+   designing pulses, or exploring what's possible. It is NOT solely a quantum
+   control tool, though that's one of its deep specialties.
+
+   Do NOT ask about experience level. Do NOT branch by expertise. The same
+   warm, brief orientation for everyone.
+
+2. **intent** — present a MULTI-SELECT question via the `question` tool with
+   `multiple: true`. The question: "What brings you to Amicode?" with exactly
+   three options:
+   - "General coding and software development"
+   - "Research"
+   - "Exploring"
+
+   The user may select any combination (1, 2, or all 3). Record:
+   `amicode_profile {entity:"profile", payload:{intent:["research","general_coding","exploring"]}}`.
+   Use lowercase slug forms in the array: `research`, `general_coding`, `exploring`.
+
+   **DO NOT ask research sub-type here.** Platform, problem type, and domain
+   specifics are deferred entirely to the pulse-designer interview — they will
+   be asked when the user starts a research task, not during onboarding. This
+   keeps the overture fast and generic.
+
+   After recording intent, acknowledge briefly ("Got it — let's get you set up")
+   and advance to the next stage. **Stages 3–8 are defined in subsequent slices**
+   — for now, after Stage 2 completes, record the completion marker:
+   `amicode_profile {entity:"onboarding_completed"}` and hand off to a normal
+   session. (Later slices will insert context-seed, demo, collection, and
+   handoff stages between intent and completion.)

packages/extension/test/scores/compiler.test.ts

@@ -82,8 +82,8 @@ describe("compileChainedScore (real overture → pulse-designer)", () => {
     expect(md).not.toContain("plain text");
   });
   it("keeps the overture's choice questions as option cards, default first (amicode#245 AC6 regression)", () => {
-    expect(md).toContain("simulation only for now (recommended)");
-    expect(md).toContain("extant QICK control code (on-prem, à la Stanford/UChicago)");
+    expect(md).toContain("Research (recommended)");
+    expect(md).toContain("General coding and software development");
   });
 });