feat: add advisor cockpit controls

Co-authored-by: Codex <noreply@openai.com>

app.py

@@ -11,6 +11,7 @@ from gradio import Server
 from hackathon_advisor.agent import AdvisorEngine
 from hackathon_advisor.data import ProjectIndex
 from hackathon_advisor.tool_contracts import resolve_tool_call, tool_schemas
+from hackathon_advisor.tools import TARGETS
 from hackathon_advisor.trace_export import build_trace_jsonl, trace_metadata
 
 
@@ -18,6 +19,7 @@ ROOT = Path(__file__).parent
 STATIC_DIR = ROOT / "static"
 DATA_PATH = ROOT / "data" / "projects.json"
 INDEX_PATH = ROOT / "data" / "project_index.json"
+PROFILE_FIELDS = ["skills", "time", "preferences", "constraints"]
 
 index = ProjectIndex.from_files(DATA_PATH, INDEX_PATH)
 engine = AdvisorEngine(index)
@@ -59,6 +61,9 @@ def bootstrap() -> dict:
         **trace_metadata(index),
         "top_projects": [project.to_public_dict() for project in index.top_projects(limit=8)],
         "whitespace": [item.to_dict() for item in index.find_whitespace(limit=5)],
+        "target_options": TARGETS,
+        "default_targets": TARGETS[:3],
+        "profile_fields": PROFILE_FIELDS,
     }
 
 

hackathon_advisor/agent.py

@@ -9,7 +9,7 @@ from hackathon_advisor.data import Project, ProjectIndex, WhitespaceItem
 from hackathon_advisor.model_runtime import ToolPlanner, create_tool_planner, runtime_status
 from hackathon_advisor.scoring import ScoreCard
 from hackathon_advisor.tool_contracts import ToolCall
-from hackathon_advisor.tools import AdvisorTools, Idea, ToolEvent, idea_from_text
+from hackathon_advisor.tools import TARGETS, AdvisorTools, Idea, ToolEvent, idea_from_text, normalize_targets, targets_from_state
 
 
 @dataclass
@@ -51,6 +51,8 @@ class AdvisorEngine:
     def turn(self, message: str, state: dict[str, Any] | None = None) -> TurnResult:
         state = dict(state or {})
         state.setdefault("ideas", [])
+        state.setdefault("profile", {})
+        state.setdefault("targets", TARGETS[:3])
         normalized, corrections = normalize_text(message)
         resolution = self.planner.plan(normalized, state)
         state["last_tool_resolution"] = resolution.to_dict()
@@ -149,19 +151,31 @@ class AdvisorEngine:
         )
 
     def _store_idea(self, state: dict[str, Any], idea: Idea) -> None:
-        state["ideas"] = [
-            idea.to_dict() if item.get("id") == idea.id else item for item in state.get("ideas", [])
-        ]
+        stored = []
+        replaced = False
+        for item in state.get("ideas", []):
+            if item.get("id") == idea.id:
+                stored.append(idea.to_dict())
+                replaced = True
+            else:
+                stored.append(item)
+        if not replaced:
+            stored.append(idea.to_dict())
+        state["ideas"] = stored
 
     def _current_idea(self, state: dict[str, Any]) -> Idea | None:
         current_id = state.get("current_idea_id")
         for item in state.get("ideas", []):
             if item.get("id") == current_id:
-                return Idea(**item)
+                return self._with_session_targets(Idea(**item), state)
         if state.get("ideas"):
-            return Idea(**state["ideas"][-1])
+            return self._with_session_targets(Idea(**state["ideas"][-1]), state)
         return None
 
+    def _with_session_targets(self, idea: Idea, state: dict[str, Any]) -> Idea:
+        idea.targets = targets_from_state(state)
+        return idea
+
     def _idea_research_turn(
         self,
         call: ToolCall,
@@ -297,7 +311,7 @@ class AdvisorEngine:
         state: dict[str, Any],
         tool_events: list[ToolEvent],
     ) -> TurnResult:
-        targets = [str(target) for target in call.arguments.get("side_quests", [])]
+        targets = normalize_targets(call.arguments.get("side_quests"), default=[])
         state["targets"] = targets
         idea = self._current_idea(state)
         if idea is not None:
@@ -312,7 +326,7 @@ class AdvisorEngine:
         if idea_id:
             for item in state.get("ideas", []):
                 if item.get("id") == idea_id:
-                    return Idea(**item)
+                    return self._with_session_targets(Idea(**item), state)
         return self._current_idea(state)
 
     def _record_trace(

hackathon_advisor/tools.py

@@ -18,6 +18,28 @@ TARGETS = [
 ]
 
 
+def normalize_targets(raw_targets: Any, default: list[str] | None = None) -> list[str]:
+    if raw_targets is None:
+        return list(default or [])
+    if not isinstance(raw_targets, list):
+        return list(default or [])
+
+    targets: list[str] = []
+    seen: set[str] = set()
+    for raw_target in raw_targets:
+        target = str(raw_target)
+        if target in TARGETS and target not in seen:
+            targets.append(target)
+            seen.add(target)
+    return targets
+
+
+def targets_from_state(state: dict[str, Any]) -> list[str]:
+    if "targets" not in state:
+        return TARGETS[:3]
+    return normalize_targets(state.get("targets"), default=[])
+
+
 @dataclass
 class Idea:
     id: str
@@ -65,13 +87,15 @@ class AdvisorTools:
     def save_idea(self, state: dict[str, Any], title: str, pitch: str) -> tuple[Idea, ToolEvent]:
         ideas = [Idea(**item) for item in state.get("ideas", [])]
         current_id = state.get("current_idea_id")
+        targets = targets_from_state(state)
         idea = next((item for item in ideas if item.id == current_id), None)
         if idea is None:
-            idea = Idea(id=uuid.uuid4().hex[:8], title=title, pitch=pitch)
+            idea = Idea(id=uuid.uuid4().hex[:8], title=title, pitch=pitch, targets=targets)
             ideas.append(idea)
         else:
             idea.title = title
             idea.pitch = pitch
+            idea.targets = targets
         state["ideas"] = [item.to_dict() for item in ideas]
         state["current_idea_id"] = idea.id
         return idea, ToolEvent("save_idea", f"Wrote idea page '{idea.title}'.")

static/app.js

@@ -8,6 +8,8 @@ const corrections = document.querySelector("#corrections");
 const projectsEl = document.querySelector("#projects");
 const whitespaceEl = document.querySelector("#whitespace");
 const ideasEl = document.querySelector("#ideas");
+const targetsEl = document.querySelector("#targets");
+const profileEl = document.querySelector("#profile");
 const scoreEl = document.querySelector("#score");
 const planEl = document.querySelector("#plan");
 const traceEl = document.querySelector("#trace");
@@ -20,6 +22,8 @@ const exportTraceButton = document.querySelector("#export-trace");
 let session = {};
 let clientPromise = Client.connect(window.location.origin);
 let currentArtifact = null;
+let targetOptions = [];
+let profileFields = [];
 
 bootstrap();
 
@@ -45,6 +49,30 @@ exportTraceButton.addEventListener("click", async () => {
   await exportTrace();
 });
 
+targetsEl.addEventListener("change", (event) => {
+  const target = event.target;
+  if (!(target instanceof HTMLInputElement) || !target.dataset.target) return;
+  const checked = new Set(
+    Array.from(targetsEl.querySelectorAll("input[data-target]:checked")).map((input) => input.dataset.target),
+  );
+  session.targets = targetOptions.filter((option) => checked.has(option));
+  syncCurrentIdeaTargets();
+  renderIdeas(session.ideas || []);
+});
+
+profileEl.addEventListener("input", (event) => {
+  const target = event.target;
+  if (!(target instanceof HTMLInputElement) || !target.dataset.profileField) return;
+  const profile = { ...(session.profile || {}) };
+  const value = target.value.trim();
+  if (value) {
+    profile[target.dataset.profileField] = value;
+  } else {
+    delete profile[target.dataset.profileField];
+  }
+  session.profile = profile;
+});
+
 async function runTurn(message) {
   input.value = "";
   submit.disabled = true;
@@ -81,7 +109,15 @@ async function runTurn(message) {
 async function bootstrap() {
   const response = await fetch("/api/bootstrap");
   const data = await response.json();
+  targetOptions = data.target_options || [];
+  profileFields = data.profile_fields || [];
+  session = {
+    profile: {},
+    targets: data.default_targets || targetOptions.slice(0, 3),
+  };
   renderProvenance(data);
+  renderTargets(session.targets);
+  renderProfile(session.profile);
   renderProjects(data.top_projects || []);
   renderWhitespace(data.whitespace || []);
   renderIdeas([]);
@@ -97,6 +133,45 @@ function renderProvenance(data) {
   provenanceEl.textContent = `${data.index_algorithm || "index"} · snapshot ${snapshot} · index ${index} · ${digest}`;
 }
 
+function renderTargets(selectedTargets) {
+  const selected = new Set(selectedTargets || []);
+  targetsEl.innerHTML = "";
+  if (!targetOptions.length) {
+    targetsEl.innerHTML = `<div class="empty">No seals loaded.</div>`;
+    return;
+  }
+  for (const option of targetOptions) {
+    const label = document.createElement("label");
+    label.className = "target-toggle";
+    label.innerHTML = `
+      <input type="checkbox" data-target="${escapeAttribute(option)}" ${selected.has(option) ? "checked" : ""} />
+      <span>${escapeHtml(option)}</span>
+    `;
+    targetsEl.append(label);
+  }
+}
+
+function renderProfile(profile) {
+  profileEl.innerHTML = "";
+  if (!profileFields.length) {
+    profileEl.innerHTML = `<div class="empty">No profile fields.</div>`;
+    return;
+  }
+  for (const field of profileFields) {
+    const row = document.createElement("label");
+    row.className = "profile-field";
+    row.innerHTML = `
+      <span>${escapeHtml(fieldLabel(field))}</span>
+      <input
+        data-profile-field="${escapeAttribute(field)}"
+        value="${escapeAttribute(profile?.[field] || "")}"
+        autocomplete="off"
+      />
+    `;
+    profileEl.append(row);
+  }
+}
+
 function handleEvent(event) {
   if (event.type === "start") {
     if (event.corrections?.length) {
@@ -114,8 +189,12 @@ function handleEvent(event) {
 
   if (event.type === "done") {
     session = event.state || {};
+    session.profile = session.profile || {};
+    session.targets = Array.isArray(session.targets) ? session.targets : [];
     if (event.projects?.length) renderProjects(event.projects);
     if (event.whitespace?.length) renderWhitespace(event.whitespace);
+    renderTargets(session.targets);
+    renderProfile(session.profile);
     renderIdeas(session.ideas || []);
     renderTrace(session.trace || []);
     renderPlan(event.plan || []);
@@ -142,12 +221,14 @@ function renderIdeas(ideas) {
   }
   for (const idea of ideas.slice(-4).reverse()) {
     const score = idea.score?.overall ? Number(idea.score.overall).toFixed(1) : "0.0";
+    const targets = (idea.targets || []).slice(0, 3).join(" · ");
     const item = document.createElement("div");
     item.className = "idea";
     item.innerHTML = `
       <strong>${escapeHtml(idea.title)}</strong>
       <p>${escapeHtml((idea.pitch || "").slice(0, 120))}</p>
       <span>${escapeHtml(idea.score?.verdict || "DRAFT")} · ${score}</span>
+      ${targets ? `<small>${escapeHtml(targets)}</small>` : ""}
     `;
     ideasEl.append(item);
   }
@@ -250,6 +331,13 @@ function setCommandDisabled(disabled) {
   });
 }
 
+function syncCurrentIdeaTargets() {
+  const currentId = session.current_idea_id;
+  if (!currentId || !Array.isArray(session.ideas)) return;
+  const idea = session.ideas.find((item) => item.id === currentId);
+  if (idea) idea.targets = [...(session.targets || [])];
+}
+
 async function exportTrace() {
   const client = await clientPromise;
   const result = await client.predict("/trace_artifact", {
@@ -377,6 +465,16 @@ function escapeHtml(value) {
     .replaceAll("'", "&#039;");
 }
 
+function escapeAttribute(value) {
+  return escapeHtml(value).replaceAll("`", "&#096;");
+}
+
+function fieldLabel(value) {
+  return String(value)
+    .replaceAll("_", " ")
+    .replace(/^\w/, (char) => char.toUpperCase());
+}
+
 function shortDate(value) {
   if (!value) return "unknown";
   return String(value).replace("T", " ").replace(/\+00:00$/, "Z").slice(0, 16);

static/index.html

@@ -46,6 +46,14 @@
             <div id="provenance" class="provenance"></div>
             <div id="score" class="score-grid" aria-label="Seal quadrants"></div>
             <div class="panels">
+              <article>
+                <h2>Targets</h2>
+                <div id="targets" class="target-list"></div>
+              </article>
+              <article>
+                <h2>Profile</h2>
+                <div id="profile" class="profile-grid"></div>
+              </article>
               <article>
                 <h2>Idea Board</h2>
                 <div id="ideas" class="idea-list"></div>

static/styles.css

@@ -278,7 +278,9 @@ button:disabled {
 .project-list,
 .whitespace-list,
 .idea-list,
-.trace-list {
+.trace-list,
+.target-list,
+.profile-grid {
   display: grid;
   gap: 9px;
 }
@@ -286,7 +288,9 @@ button:disabled {
 .project,
 .gap,
 .idea,
-.trace {
+.trace,
+.target-toggle,
+.profile-field {
   border-left: 3px solid rgba(80, 47, 22, 0.48);
   padding: 8px 10px;
   background: rgba(255, 241, 196, 0.34);
@@ -322,6 +326,75 @@ button:disabled {
   letter-spacing: 0.04em;
 }
 
+.idea small {
+  display: block;
+  margin-top: 4px;
+  color: #5f6d38;
+  font-size: 0.72rem;
+  line-height: 1.25;
+  font-weight: 900;
+}
+
+.target-list {
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 7px;
+}
+
+.target-toggle {
+  min-width: 0;
+  min-height: 36px;
+  display: flex;
+  align-items: center;
+  gap: 7px;
+  color: #2a170d;
+  font-size: 0.76rem;
+  line-height: 1.2;
+  font-weight: 900;
+  cursor: pointer;
+}
+
+.target-toggle input {
+  flex: 0 0 auto;
+  width: 16px;
+  height: 16px;
+  accent-color: var(--leaf);
+}
+
+.target-toggle span {
+  min-width: 0;
+}
+
+.profile-field {
+  min-width: 0;
+  display: grid;
+  grid-template-columns: 78px minmax(0, 1fr);
+  align-items: center;
+  gap: 8px;
+}
+
+.profile-field span {
+  color: var(--muted-ink);
+  font-size: 0.76rem;
+  line-height: 1.2;
+  font-weight: 900;
+}
+
+.profile-field input {
+  min-width: 0;
+  height: 32px;
+  border: 1px solid rgba(80, 47, 22, 0.32);
+  border-radius: 8px;
+  padding: 0 9px;
+  background: rgba(255, 243, 203, 0.48);
+  color: var(--ink);
+  outline: none;
+}
+
+.profile-field input:focus {
+  border-color: rgba(47, 122, 73, 0.72);
+  box-shadow: 0 0 0 3px rgba(47, 122, 73, 0.13);
+}
+
 .plan-list {
   display: grid;
   gap: 7px;
@@ -370,6 +443,10 @@ button:disabled {
     grid-template-columns: 1fr;
   }
 
+  .target-list {
+    grid-template-columns: 1fr;
+  }
+
   .command-row {
     grid-template-columns: repeat(3, minmax(0, 1fr));
   }

tests/test_agent.py

@@ -106,6 +106,31 @@ def test_planner_profile_and_targets_update_state() -> None:
     assert targeted.state["targets"] == ["Off the Grid", "Field Notes"]
 
 
+def test_session_targets_apply_to_new_and_current_ideas() -> None:
+    index = ProjectIndex.from_files(Path("data/projects.json"), Path("data/project_index.json"))
+    engine = AdvisorEngine(index)
+    state = {"targets": ["Field Notes"]}
+
+    first = engine.turn("A local-first archive cartographer for family photos", state)
+    first_idea = first.state["ideas"][0]
+    planned = engine.turn("make a build plan", first.state)
+
+    assert first_idea["targets"] == ["Field Notes"]
+    assert all("LoRA" not in step for step in planned.plan)
+
+
+def test_well_tuned_target_adds_training_step_to_plan() -> None:
+    index = ProjectIndex.from_files(Path("data/projects.json"), Path("data/project_index.json"))
+    engine = AdvisorEngine(index)
+    state = {"targets": ["Well-Tuned"]}
+
+    first = engine.turn("A local-first archive cartographer for family photos", state)
+    planned = engine.turn("make a build plan", first.state)
+
+    assert first.state["ideas"][0]["targets"] == ["Well-Tuned"]
+    assert any("LoRA" in step for step in planned.plan)
+
+
 def test_planner_score_idea_scores_current_idea() -> None:
     index = ProjectIndex.from_files(Path("data/projects.json"), Path("data/project_index.json"))
     first = AdvisorEngine(index).turn("A local-first archive cartographer for family photos", {})

tests/test_app.py

@@ -21,6 +21,8 @@ def test_bootstrap_exposes_index_metadata() -> None:
     assert payload["snapshot_digest"]
     assert payload["runtime"]["tool_count"] >= 8
     assert payload["top_projects"]
+    assert payload["default_targets"] == payload["target_options"][:3]
+    assert "skills" in payload["profile_fields"]
 
 
 def test_trace_artifact_endpoint_exports_jsonl() -> None: