gsd-pi 2.29.0-dev.953d788 → 2.29.0-dev.f08b4fe

package/src/resources/extensions/gsd/auto.ts

@@ -22,7 +22,6 @@ import { loadFile, getManifestStatus, resolveAllOverrides, parsePlan, parseSumma
 import { loadPrompt } from "./prompt-loader.js";
 import { runVerificationGate, formatFailureContext, captureRuntimeErrors, runDependencyAudit } from "./verification-gate.js";
 import { writeVerificationJSON } from "./verification-evidence.js";
-export { inlinePriorMilestoneSummary } from "./files.js";
 import { collectSecretsFromManifest } from "../get-secrets-from-user.js";
 import {
   gsdRoot, resolveMilestoneFile, resolveSliceFile, resolveSlicePath,
@@ -70,12 +69,10 @@ import { closeoutUnit } from "./auto-unit-closeout.js";
 import { recoverTimedOutUnit } from "./auto-timeout-recovery.js";
 import { selectAndApplyModel } from "./auto-model-selection.js";
 import {
-  syncProjectRootToWorktree,
-  syncStateToProjectRoot,
   readResourceVersion,
   checkResourcesStale,
   escapeStaleWorktree,
-} from "./auto-worktree-sync.js";
+} from "./resource-version.js";
 import { initRoutingHistory, resetRoutingHistory, recordOutcome } from "./routing-history.js";
 import {
   checkPostUnitHooks,
@@ -181,7 +178,7 @@ import { runPostUnitVerification, type VerificationContext } from "./auto-verifi
 import { postUnitPreVerification, postUnitPostVerification, type PostUnitContext } from "./auto-post-unit.js";
 import { bootstrapAutoSession, type BootstrapDeps } from "./auto-start.js";
 
-// Worktree sync, resource staleness, stale worktree escape → auto-worktree-sync.ts
+// Resource staleness, stale worktree escape → resource-version.ts
 
 // ─── Session State ─────────────────────────────────────────────────────────
 
@@ -192,12 +189,6 @@ import {
   NEW_SESSION_TIMEOUT_MS, DISPATCH_HANG_TIMEOUT_MS,
 } from "./auto/session.js";
 import type { CompletedUnit, CurrentUnit, UnitRouting, StartModel, PendingVerificationRetry } from "./auto/session.js";
-export {
-  MAX_UNIT_DISPATCHES, STUB_RECOVERY_THRESHOLD, MAX_LIFETIME_DISPATCHES,
-  MAX_CONSECUTIVE_SKIPS, DISPATCH_GAP_TIMEOUT_MS, MAX_SKIP_DEPTH,
-  NEW_SESSION_TIMEOUT_MS, DISPATCH_HANG_TIMEOUT_MS,
-} from "./auto/session.js";
-export type { CompletedUnit, CurrentUnit, UnitRouting, StartModel } from "./auto/session.js";
 
 // ── ENCAPSULATION INVARIANT ─────────────────────────────────────────────────
 // ALL mutable auto-mode state lives in the AutoSession class (auto/session.ts).
@@ -268,8 +259,6 @@ export function shouldUseWorktreeIsolation(): boolean {
  * Maps toolCallId → start timestamp (ms) so the idle watchdog can detect tools that have been
  * running suspiciously long (e.g., a Bash command hung because `&` kept stdout open).
  */
-// Re-export budget utilities for external consumers
-export { getBudgetAlertLevel, getNewBudgetAlertLevel, getBudgetEnforcementAction } from "./auto-budget.js";
 
 /** Wrapper: register SIGTERM handler and store reference. */
 function registerSigtermHandler(currentBasePath: string): void {
@@ -282,8 +271,6 @@ function deregisterSigtermHandler(): void {
   s.sigtermHandler = null;
 }
 
-export { type AutoDashboardData } from "./auto-dashboard.js";
-
 export function getAutoDashboardData(): AutoDashboardData {
   const ledger = getLedger();
   const totals = ledger ? getProjectTotals(ledger.units) : null;
@@ -934,8 +921,6 @@ async function showStepWizard(
   }
 }
 
-// describeNextUnit is imported from auto-dashboard.ts and re-exported
-export { describeNextUnit } from "./auto-dashboard.js";
 
 /** Thin wrapper: delegates to auto-dashboard.ts, passing state accessors. */
 function updateProgressWidget(
@@ -1031,11 +1016,6 @@ async function dispatchNextUnit(
     // Non-fatal
   }
 
-  // ── Sync project root artifacts into worktree ──
-  if (s.originalBasePath && s.basePath !== s.originalBasePath && s.currentMilestoneId) {
-    syncProjectRootToWorktree(s.originalBasePath, s.basePath, s.currentMilestoneId);
-  }
-
   const stopDeriveTimer = debugTime("derive-state");
   let state = await deriveState(s.basePath);
   stopDeriveTimer({
@@ -1905,5 +1885,3 @@ export async function dispatchHookUnit(
 }
 
 
-// Direct phase dispatch → auto-direct-dispatch.ts
-export { dispatchDirectPhase } from "./auto-direct-dispatch.js";

package/src/resources/extensions/gsd/captures.ts

@@ -9,9 +9,10 @@
  */
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
-import { join, resolve, sep } from "node:path";
+import { join, resolve } from "node:path";
 import { randomUUID } from "node:crypto";
 import { gsdRoot } from "./paths.js";
+import { resolveProjectRoot } from "./worktree.js";
 
 // ─── Types ────────────────────────────────────────────────────────────────────
 
@@ -58,15 +59,8 @@ const VALID_CLASSIFICATIONS: readonly string[] = [
  * directory that contains `.gsd/worktrees/` — that's the project root.
  */
 export function resolveCapturesPath(basePath: string): string {
-  const resolved = resolve(basePath);
-  const worktreeMarker = `${sep}.gsd${sep}worktrees${sep}`;
-  const idx = resolved.indexOf(worktreeMarker);
-  if (idx !== -1) {
-    // basePath is inside a worktree — resolve to project root
-    const projectRoot = resolved.slice(0, idx);
-    return join(projectRoot, ".gsd", CAPTURES_FILENAME);
-  }
-  return join(gsdRoot(basePath), CAPTURES_FILENAME);
+  const projectRoot = resolveProjectRoot(resolve(basePath));
+  return join(gsdRoot(projectRoot), CAPTURES_FILENAME);
 }
 
 // ─── File I/O ─────────────────────────────────────────────────────────────────

package/src/resources/extensions/gsd/commands-extensions.ts

@@ -0,0 +1,328 @@
+/**
+ * GSD Extensions Command — /gsd extensions
+ *
+ * Manage the extension registry: list, enable, disable, info.
+ * Self-contained — no imports outside the extensions tree (extensions are loaded
+ * via jiti at runtime from ~/.gsd/agent/, not compiled by tsc).
+ */
+
+import type { ExtensionCommandContext } from "@gsd/pi-coding-agent";
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+
+// ─── Types (mirrored from extension-registry.ts) ────────────────────────────
+
+interface ExtensionManifest {
+  id: string;
+  name: string;
+  version: string;
+  description: string;
+  tier: "core" | "bundled" | "community";
+  requires: { platform: string };
+  provides?: {
+    tools?: string[];
+    commands?: string[];
+    hooks?: string[];
+    shortcuts?: string[];
+  };
+  dependencies?: {
+    extensions?: string[];
+    runtime?: string[];
+  };
+}
+
+interface ExtensionRegistryEntry {
+  id: string;
+  enabled: boolean;
+  source: "bundled" | "user" | "project";
+  disabledAt?: string;
+  disabledReason?: string;
+}
+
+interface ExtensionRegistry {
+  version: 1;
+  entries: Record<string, ExtensionRegistryEntry>;
+}
+
+// ─── Registry I/O ───────────────────────────────────────────────────────────
+
+function getRegistryPath(): string {
+  return join(homedir(), ".gsd", "extensions", "registry.json");
+}
+
+function getAgentExtensionsDir(): string {
+  return join(homedir(), ".gsd", "agent", "extensions");
+}
+
+function loadRegistry(): ExtensionRegistry {
+  const filePath = getRegistryPath();
+  try {
+    if (!existsSync(filePath)) return { version: 1, entries: {} };
+    const raw = readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && parsed.version === 1 && typeof parsed.entries === "object") {
+      return parsed as ExtensionRegistry;
+    }
+    return { version: 1, entries: {} };
+  } catch {
+    return { version: 1, entries: {} };
+  }
+}
+
+function saveRegistry(registry: ExtensionRegistry): void {
+  const filePath = getRegistryPath();
+  try {
+    mkdirSync(dirname(filePath), { recursive: true });
+    const tmp = filePath + ".tmp";
+    writeFileSync(tmp, JSON.stringify(registry, null, 2), "utf-8");
+    renameSync(tmp, filePath);
+  } catch { /* non-fatal */ }
+}
+
+function isEnabled(registry: ExtensionRegistry, id: string): boolean {
+  const entry = registry.entries[id];
+  if (!entry) return true;
+  return entry.enabled;
+}
+
+function readManifest(dir: string): ExtensionManifest | null {
+  const mPath = join(dir, "extension-manifest.json");
+  if (!existsSync(mPath)) return null;
+  try {
+    const raw = JSON.parse(readFileSync(mPath, "utf-8"));
+    if (typeof raw?.id === "string" && typeof raw?.name === "string") return raw as ExtensionManifest;
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+function discoverManifests(): Map<string, ExtensionManifest> {
+  const extDir = getAgentExtensionsDir();
+  const manifests = new Map<string, ExtensionManifest>();
+  if (!existsSync(extDir)) return manifests;
+  for (const entry of readdirSync(extDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const m = readManifest(join(extDir, entry.name));
+    if (m) manifests.set(m.id, m);
+  }
+  return manifests;
+}
+
+// ─── Command Handler ────────────────────────────────────────────────────────
+
+export async function handleExtensions(args: string, ctx: ExtensionCommandContext): Promise<void> {
+  const parts = args.split(/\s+/).filter(Boolean);
+  const subCmd = parts[0] ?? "list";
+
+  if (subCmd === "list") {
+    handleList(ctx);
+    return;
+  }
+
+  if (subCmd === "enable") {
+    handleEnable(parts[1], ctx);
+    return;
+  }
+
+  if (subCmd === "disable") {
+    handleDisable(parts[1], parts.slice(2).join(" "), ctx);
+    return;
+  }
+
+  if (subCmd === "info") {
+    handleInfo(parts[1], ctx);
+    return;
+  }
+
+  ctx.ui.notify(
+    `Unknown: /gsd extensions ${subCmd}. Usage: /gsd extensions [list|enable|disable|info]`,
+    "warning",
+  );
+}
+
+function handleList(ctx: ExtensionCommandContext): void {
+  const manifests = discoverManifests();
+  const registry = loadRegistry();
+
+  if (manifests.size === 0) {
+    ctx.ui.notify("No extension manifests found.", "warning");
+    return;
+  }
+
+  // Sort: core first, then alphabetical
+  const sorted = [...manifests.values()].sort((a, b) => {
+    if (a.tier === "core" && b.tier !== "core") return -1;
+    if (b.tier === "core" && a.tier !== "core") return 1;
+    return a.id.localeCompare(b.id);
+  });
+
+  const lines: string[] = [];
+  const hdr = padRight("Extensions", 38) + padRight("Status", 10) + padRight("Tier", 10) + padRight("Tools", 7) + "Commands";
+  lines.push(hdr);
+  lines.push("─".repeat(hdr.length));
+
+  for (const m of sorted) {
+    const enabled = isEnabled(registry, m.id);
+    const status = enabled ? "enabled" : "disabled";
+    const toolCount = m.provides?.tools?.length ?? 0;
+    const cmdCount = m.provides?.commands?.length ?? 0;
+    const label = `${m.id} (${m.name})`;
+
+    lines.push(
+      padRight(label, 38) +
+      padRight(status, 10) +
+      padRight(m.tier, 10) +
+      padRight(String(toolCount), 7) +
+      String(cmdCount),
+    );
+
+    if (!enabled) {
+      lines.push(`  ↳ gsd extensions enable ${m.id}`);
+    }
+  }
+
+  ctx.ui.notify(lines.join("\n"), "info");
+}
+
+function handleEnable(id: string | undefined, ctx: ExtensionCommandContext): void {
+  if (!id) {
+    ctx.ui.notify("Usage: /gsd extensions enable <id>", "warning");
+    return;
+  }
+
+  const manifests = discoverManifests();
+  if (!manifests.has(id)) {
+    ctx.ui.notify(`Extension "${id}" not found. Run /gsd extensions list to see available extensions.`, "warning");
+    return;
+  }
+
+  const registry = loadRegistry();
+  if (isEnabled(registry, id)) {
+    ctx.ui.notify(`Extension "${id}" is already enabled.`, "info");
+    return;
+  }
+
+  const entry = registry.entries[id];
+  if (entry) {
+    entry.enabled = true;
+    delete entry.disabledAt;
+    delete entry.disabledReason;
+  } else {
+    registry.entries[id] = { id, enabled: true, source: "bundled" };
+  }
+  saveRegistry(registry);
+  ctx.ui.notify(`Enabled "${id}". Restart GSD to activate.`, "info");
+}
+
+function handleDisable(id: string | undefined, reason: string, ctx: ExtensionCommandContext): void {
+  if (!id) {
+    ctx.ui.notify("Usage: /gsd extensions disable <id>", "warning");
+    return;
+  }
+
+  const manifests = discoverManifests();
+  const manifest = manifests.get(id) ?? null;
+
+  if (!manifests.has(id)) {
+    ctx.ui.notify(`Extension "${id}" not found. Run /gsd extensions list to see available extensions.`, "warning");
+    return;
+  }
+
+  if (manifest?.tier === "core") {
+    ctx.ui.notify(`Cannot disable "${id}" — it is a core extension.`, "warning");
+    return;
+  }
+
+  const registry = loadRegistry();
+  if (!isEnabled(registry, id)) {
+    ctx.ui.notify(`Extension "${id}" is already disabled.`, "info");
+    return;
+  }
+
+  const entry = registry.entries[id];
+  if (entry) {
+    entry.enabled = false;
+    entry.disabledAt = new Date().toISOString();
+    entry.disabledReason = reason || undefined;
+  } else {
+    registry.entries[id] = {
+      id,
+      enabled: false,
+      source: "bundled",
+      disabledAt: new Date().toISOString(),
+      disabledReason: reason || undefined,
+    };
+  }
+  saveRegistry(registry);
+  ctx.ui.notify(`Disabled "${id}". Restart GSD to deactivate.`, "info");
+}
+
+function handleInfo(id: string | undefined, ctx: ExtensionCommandContext): void {
+  if (!id) {
+    ctx.ui.notify("Usage: /gsd extensions info <id>", "warning");
+    return;
+  }
+
+  const manifests = discoverManifests();
+  const manifest = manifests.get(id);
+  if (!manifest) {
+    ctx.ui.notify(`Extension "${id}" not found.`, "warning");
+    return;
+  }
+
+  const registry = loadRegistry();
+  const enabled = isEnabled(registry, id);
+  const entry = registry.entries[id];
+
+  const lines: string[] = [
+    `${manifest.name} (${manifest.id})`,
+    "",
+    `  Version:     ${manifest.version}`,
+    `  Description: ${manifest.description}`,
+    `  Tier:        ${manifest.tier}`,
+    `  Status:      ${enabled ? "enabled" : "disabled"}`,
+  ];
+
+  if (entry?.disabledAt) {
+    lines.push(`  Disabled at: ${entry.disabledAt}`);
+  }
+  if (entry?.disabledReason) {
+    lines.push(`  Reason:      ${entry.disabledReason}`);
+  }
+
+  if (manifest.provides) {
+    lines.push("");
+    lines.push("  Provides:");
+    if (manifest.provides.tools?.length) {
+      lines.push(`    Tools:     ${manifest.provides.tools.join(", ")}`);
+    }
+    if (manifest.provides.commands?.length) {
+      lines.push(`    Commands:  ${manifest.provides.commands.join(", ")}`);
+    }
+    if (manifest.provides.hooks?.length) {
+      lines.push(`    Hooks:     ${manifest.provides.hooks.join(", ")}`);
+    }
+    if (manifest.provides.shortcuts?.length) {
+      lines.push(`    Shortcuts: ${manifest.provides.shortcuts.join(", ")}`);
+    }
+  }
+
+  if (manifest.dependencies) {
+    lines.push("");
+    lines.push("  Dependencies:");
+    if (manifest.dependencies.extensions?.length) {
+      lines.push(`    Extensions: ${manifest.dependencies.extensions.join(", ")}`);
+    }
+    if (manifest.dependencies.runtime?.length) {
+      lines.push(`    Runtime:    ${manifest.dependencies.runtime.join(", ")}`);
+    }
+  }
+
+  ctx.ui.notify(lines.join("\n"), "info");
+}
+
+function padRight(str: string, len: number): string {
+  return str.length >= len ? str + " " : str + " ".repeat(len - str.length);
+}

package/src/resources/extensions/gsd/commands-handlers.ts

@@ -9,6 +9,7 @@ import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent
 import { existsSync, readFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { deriveState } from "./state.js";
+import { gsdRoot } from "./paths.js";
 import { appendCapture, hasPendingCaptures, loadPendingCaptures } from "./captures.js";
 import { appendOverride, appendKnowledge } from "./files.js";
 import {
@@ -19,7 +20,26 @@ import {
   filterDoctorIssues,
 } from "./doctor.js";
 import { isAutoActive } from "./auto.js";
-import { projectRoot, dispatchDoctorHeal } from "./commands.js";
+import { projectRoot } from "./commands.js";
+import { loadPrompt } from "./prompt-loader.js";
+
+export function dispatchDoctorHeal(pi: ExtensionAPI, scope: string | undefined, reportText: string, structuredIssues: string): void {
+  const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(process.env.HOME ?? "~", ".pi", "GSD-WORKFLOW.md");
+  const workflow = readFileSync(workflowPath, "utf-8");
+  const prompt = loadPrompt("doctor-heal", {
+    doctorSummary: reportText,
+    structuredIssues,
+    scopeLabel: scope ?? "active milestone / blocking scope",
+    doctorCommandSuffix: scope ? ` ${scope}` : "",
+  });
+
+  const content = `Read the following GSD workflow protocol and execute exactly.\n\n${workflow}\n\n## Your Task\n\n${prompt}`;
+
+  pi.sendMessage(
+    { customType: "gsd-doctor-heal", content, display: false },
+    { triggerTurn: true },
+  );
+}
 
 export async function handleDoctor(args: string, ctx: ExtensionCommandContext, pi: ExtensionAPI): Promise<void> {
   const trimmed = args.trim();
@@ -117,7 +137,7 @@ export async function handleCapture(args: string, ctx: ExtensionCommandContext):
   const basePath = process.cwd();
 
   // Ensure .gsd/ exists — capture should work even without a milestone
-  const gsdDir = join(basePath, ".gsd");
+  const gsdDir = gsdRoot(basePath);
   if (!existsSync(gsdDir)) {
     mkdirSync(gsdDir, { recursive: true });
   }

package/src/resources/extensions/gsd/commands-logs.ts

@@ -14,6 +14,7 @@ import type { ExtensionCommandContext } from "@gsd/pi-coding-agent";
 import { existsSync, readdirSync, readFileSync, statSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
+import { loadJsonFileOrNull } from "./json-persistence.js";
 
 // ─── Types ──────────────────────────────────────────────────────────────────
 
@@ -331,20 +332,18 @@ async function handleLogsList(basePath: string, ctx: ExtensionCommandContext): P
 
   // Metrics summary
   const metricsPath = join(gsdRoot(basePath), "metrics.json");
-  if (existsSync(metricsPath)) {
-    try {
-      const metrics = JSON.parse(readFileSync(metricsPath, "utf-8"));
-      const units = metrics?.units;
-      if (Array.isArray(units) && units.length > 0) {
-        const totalCost = units.reduce((sum: number, u: Record<string, unknown>) => sum + ((u.cost as number) ?? 0), 0);
-        const totalTokens = units.reduce((sum: number, u: Record<string, unknown>) => {
-          const t = u.tokens as Record<string, number> | undefined;
-          return sum + (t?.total ?? 0);
-        }, 0);
-        lines.push("");
-        lines.push(`Metrics: ${units.length} units tracked · $${totalCost.toFixed(2)} · ${(totalTokens / 1000).toFixed(0)}K tokens`);
-      }
-    } catch { /* ignore */ }
+  const isMetrics = (d: unknown): d is { units: Array<Record<string, unknown>> } =>
+    d !== null && typeof d === "object" && "units" in d! && Array.isArray((d as Record<string, unknown>).units);
+  const metrics = loadJsonFileOrNull(metricsPath, isMetrics);
+  if (metrics && metrics.units.length > 0) {
+    const units = metrics.units;
+    const totalCost = units.reduce((sum: number, u) => sum + ((u.cost as number) ?? 0), 0);
+    const totalTokens = units.reduce((sum: number, u) => {
+      const t = u.tokens as Record<string, number> | undefined;
+      return sum + (t?.total ?? 0);
+    }, 0);
+    lines.push("");
+    lines.push(`Metrics: ${units.length} units tracked · $${totalCost.toFixed(2)} · ${(totalTokens / 1000).toFixed(0)}K tokens`);
   }
 
   lines.push("");

package/src/resources/extensions/gsd/commands-prefs-wizard.ts

@@ -260,27 +260,57 @@ async function configureModels(ctx: ExtensionCommandContext, prefs: Record<strin
       group.push(m);
     }
     const providers = Array.from(byProvider.keys()).sort((a, b) => a.localeCompare(b));
-
-    const modelOptions: string[] = [];
-    for (const provider of providers) {
-      const group = byProvider.get(provider)!;
-      modelOptions.push(`─── ${provider} (${group.length}) ───`);
-      for (const m of group) {
-        modelOptions.push(`${m.id} · ${m.provider}`);
-      }
+    // Sort models within each provider
+    for (const group of byProvider.values()) {
+      group.sort((a, b) => a.id.localeCompare(b.id));
     }
-    modelOptions.push("(keep current)", "(clear)");
+
+    // Build provider menu with model counts
+    const providerOptions = providers.map(p => {
+      const count = byProvider.get(p)!.length;
+      return `${p} (${count} models)`;
+    });
+    providerOptions.push("(keep current)", "(clear)", "(type manually)");
 
     for (const phase of modelPhases) {
       const current = models[phase] ?? "";
-      const title = `Model for ${phase} phase${current ? ` (current: ${current})` : ""}:`;
-      const choice = await ctx.ui.select(title, modelOptions);
+      const phaseLabel = `Model for ${phase} phase${current ? ` (current: ${current})` : ""}`;
+
+      // Step 1: pick provider
+      const providerChoice = await ctx.ui.select(`${phaseLabel} — choose provider:`, providerOptions);
+      if (!providerChoice || typeof providerChoice !== "string" || providerChoice === "(keep current)") continue;
+
+      if (providerChoice === "(clear)") {
+        delete models[phase];
+        continue;
+      }
+
+      if (providerChoice === "(type manually)") {
+        const input = await ctx.ui.input(
+          `${phaseLabel} — enter model ID:`,
+          current || "e.g. claude-sonnet-4-20250514",
+        );
+        if (input !== null && input !== undefined) {
+          const val = input.trim();
+          if (val) models[phase] = val;
+        }
+        continue;
+      }
+
+      // Step 2: pick model within provider
+      const providerName = providerChoice.replace(/ \(\d+ models?\)$/, "");
+      const group = byProvider.get(providerName);
+      if (!group) continue;
+
+      const modelOptions = group.map(m => m.id);
+      modelOptions.push("(keep current)", "(clear)");
 
-      if (choice && typeof choice === "string" && choice !== "(keep current)") {
-        if (choice === "(clear)") {
+      const modelChoice = await ctx.ui.select(`${phaseLabel} — ${providerName}:`, modelOptions);
+      if (modelChoice && typeof modelChoice === "string" && modelChoice !== "(keep current)") {
+        if (modelChoice === "(clear)") {
           delete models[phase];
         } else {
-          models[phase] = choice.split(" · ")[0];
+          models[phase] = modelChoice;
         }
       }
     }