aa

Author: HaibaraAi137

frontend/src/App.tsx

@@ -11,7 +11,7 @@ import {
 } from "lucide-react";
 import { api } from "./api/client";
 import type { SettingsState } from "./api/client";
-import { useArchitecture, useProject, useProjects } from "./api/queries";
+import { useArchitecture, useArtifacts, useProject, useProjects } from "./api/queries";
 import { useLiveLabEvents } from "./api/sse";
 import { LabProjectPanel } from "./components/LabProjectPanel";
 import { PixelLab } from "./components/PixelLab";
@@ -88,6 +88,25 @@ export function App() {
   const liveLabProjectId =
     selectedProjectId && liveProject?.is_running ? selectedProjectId : null;
   const liveLab = useLiveLabEvents(liveLabProjectId, labArchitecture);
+  // Fetch the active project's artifacts so PixelLab idle bubbles can
+  // pull project-specific text instead of the generic placeholder
+  // pool. Refreshes on a slow polling cadence (the underlying query
+  // refetches when the iteration finishes via the queryKey invalidation
+  // in useLiveLabEvents). Empty / unavailable projects produce an
+  // empty map; PixelLab falls back to IDLE_BUBBLE_LINES.
+  const { data: artifactsForLab } = useArtifacts(selectedProjectId);
+  const labAgentClaims = (() => {
+    if (!artifactsForLab) return undefined;
+    const out: Record<string, string[]> = {};
+    for (const a of artifactsForLab) {
+      const claim = (a.claim || "").trim();
+      if (!claim) continue;
+      const author = a.author || "";
+      if (!author) continue;
+      (out[author] ??= []).push(claim);
+    }
+    return out;
+  })();
   const labMode: "live" | "idle" | "demo" = selectedProjectId
     ? liveProject?.is_running
       ? "live"
@@ -266,6 +285,7 @@ export function App() {
                     (liveProject.total_output_tokens ?? 0)
                   : undefined
               }
+              agentClaims={labAgentClaims}
             />
             <div className="timeline">
               <LabStatusStrip

frontend/src/api/types.ts

@@ -96,12 +96,21 @@ export interface ArtifactView {
   author: string;
   kind: string;
   claim: string;
-  confidence: number;
   assumptions: string[];
   evidence: string[];
   equations: string[];
   failure_modes: string[];
   next_steps: string[];
+  /** Lifecycle state — replaces the old confidence float. Values:
+   *  provisional / accept / cite_only / defer / reject. See
+   *  src/halfseed/state/artifact_state.py for the rules. */
+  state?: string;
+  /** Critique severity ('blocker' | 'warning' | 'minor'); empty for
+   *  non-critique artifacts. */
+  severity?: string;
+  /** For critique-kind artifacts: id of the artifact this critique
+   *  targets. Empty for non-critique or paper-level critiques. */
+  critique_target_id?: string;
   approval_status: ApprovalStatus;
   approval_note: string;
   code: string;
@@ -142,6 +151,9 @@ export interface StartIterationRequest {
   token_cap?: number;
   wall_clock_seconds?: number;
   model?: string | null;
+  /** How many iterations to run back-to-back. Server caps at 20.
+   *  Default 1 = legacy single-iteration behaviour. */
+  max_iterations?: number;
 }
 
 export interface StartIterationResponse {

frontend/src/components/PixelLab.tsx

@@ -30,6 +30,18 @@ interface PixelLabProps {
    * Sourced from the project summary endpoint, not from SSE.
    */
   liveTokens?: number;
+  /**
+   * Per-agent pool of recent artifact claims for the active project.
+   * The lab pulls one of these (with low probability and trimmed) into
+   * an idle bubble so the room reads as "talking about this project's
+   * actual research", not the bundled placeholder lines. Empty when
+   * the project has no artifacts yet — the lab falls back to the
+   * generic IDLE_BUBBLE_LINES in that case.
+   *
+   * Keyed by the agent id whose `author` produced the artifact. Lab
+   * code matches case-sensitively; callers should not normalize.
+   */
+  agentClaims?: Record<string, string[]>;
 }
 
 // Compact 16:9.5 virtual canvas — feels like a single screen rather than a
@@ -219,7 +231,8 @@ export function PixelLab({
   selectedArtifactId,
   mode = "demo",
   phaseEvents,
-  liveTokens
+  liveTokens,
+  agentClaims
 }: PixelLabProps) {
   const hostRef = useRef<HTMLDivElement | null>(null);
   const floorPlanForUi = useMemo(
@@ -232,6 +245,11 @@ export function PixelLab({
   const eventStartedAtRef = useRef(performance.now() / 1000);
   const motionsRef = useRef<Record<string, AgentMotion>>({});
   const bubblesRef = useRef<SpeechBubble[]>([]);
+  // Mutable ref so the long-running Pixi tick loop sees the latest
+  // claims without being torn down every time the artifact list
+  // refreshes from the API.
+  const agentClaimsRef = useRef<Record<string, string[]>>(agentClaims ?? {});
+  agentClaimsRef.current = agentClaims ?? {};
   const cardsRef = useRef<FlyingCard[]>([]);
   const trayRef = useRef<TrayState>({ count: 0, recent: [] });
   const bannersRef = useRef<Banner[]>([]);
@@ -470,7 +488,8 @@ export function PixelLab({
               spriteAtlas: spriteAtlasRef.current,
               banners: bannersRef.current,
               confetti: confettiRef.current,
-              hud: hudRef.current
+              hud: hudRef.current,
+              agentClaims: agentClaimsRef.current
             },
             now,
             dt,
@@ -591,6 +610,8 @@ function drawScene(
     banners: Banner[];
     confetti: Confetti[];
     hud: HudState;
+    /** Per-agent pool of recent artifact claims; see PixelLabProps. */
+    agentClaims?: Record<string, string[]>;
   },
   seconds: number,
   dt: number,
@@ -651,7 +672,10 @@ function drawScene(
       state.mode === "demo" ||
       (state.mode === "live" && noActiveRole);
     if (idleLike) {
-      stepIdleAutonomy(motions, agent, home, enabledSameFloorAgents, bubbles, seconds, dt);
+      stepIdleAutonomy(
+        motions, agent, home, enabledSameFloorAgents, bubbles, seconds, dt,
+        state.agentClaims,
+      );
     } else {
       stepAgentMotion(motions, agent, home, index, state.activeEvent, seconds, progress, dt);
     }
@@ -1400,14 +1424,48 @@ const IDLE_BUBBLE_LINES = [
   "what day is it"
 ];
 
+const IDLE_BUBBLE_MAX_CHARS = 56;
+/** Probability the idle bubble pulls a real artifact claim (when one
+ * is available) instead of a generic line. Tuned by feel: too high and
+ * the lab becomes a wall of project text with no breathing room; too
+ * low and the project context never shows. ~55% reads as "the lab is
+ * actually working on something specific". */
+const IDLE_CLAIM_PROB = 0.55;
+
+function pickIdleBubbleText(
+  agent: AgentConfig,
+  agentClaims: Record<string, string[]> | undefined
+): string {
+  // Try the active project's artifacts first: prefer claims authored
+  // by this agent itself, then any author. Fall back to the generic
+  // pool. We pick the agent's own claims first so the room reads as
+  // "Numerical is mumbling about its own measurement", not "Numerical
+  // is randomly quoting the Skeptic".
+  if (agentClaims && Math.random() < IDLE_CLAIM_PROB) {
+    const own = agentClaims[agent.id];
+    if (own && own.length > 0) {
+      return truncate(own[Math.floor(Math.random() * own.length)], IDLE_BUBBLE_MAX_CHARS);
+    }
+    // Pool of claims from any agent in this project. Fine to sample
+    // across — even a Skeptic mumbling another agent's claim reads
+    // as "actively engaged with the project".
+    const all = Object.values(agentClaims).flat();
+    if (all.length > 0) {
+      return truncate(all[Math.floor(Math.random() * all.length)], IDLE_BUBBLE_MAX_CHARS);
+    }
+  }
+  return IDLE_BUBBLE_LINES[Math.floor(Math.random() * IDLE_BUBBLE_LINES.length)];
+}
+
 function stepIdleAutonomy(
   motions: Record<string, AgentMotion>,
   agent: AgentConfig,
   home: AgentHome,
   enabledAgents: AgentConfig[],
   bubbles: SpeechBubble[],
   seconds: number,
-  dt: number
+  dt: number,
+  agentClaims?: Record<string, string[]>
 ) {
   let motion = motions[agent.id] as IdleMotion | undefined;
   if (!motion) {
@@ -1424,7 +1482,7 @@ function stepIdleAutonomy(
     if (motion.idle.kind === "chat" || (motion.idle.kind === "loiter" && Math.random() < 0.25)) {
       bubbles.push({
         agentId: agent.id,
-        text: IDLE_BUBBLE_LINES[Math.floor(Math.random() * IDLE_BUBBLE_LINES.length)],
+        text: pickIdleBubbleText(agent, agentClaims),
         startedAt: seconds,
         durationSec: 2.4
       });

frontend/src/styles.css

@@ -1804,6 +1804,33 @@ button {
   font: inherit;
 }
 
+/* Multi-iteration progress strip. Renders during a run (showing
+ * "Iteration 2 of 5") and after a run completes (showing the stop
+ * reason once). Hidden when no run is active and target = 1.
+ * Sits between the runner options and the SSE event log. */
+.runProgressStrip {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  padding: 6px 10px;
+  margin: 6px 0;
+  background: #f3eada;
+  border: 1px solid #c8b890;
+  border-radius: 4px;
+  font-size: 12px;
+  color: #4d4434;
+}
+.runProgressStrip code {
+  background: #fffaf0;
+  padding: 0 4px;
+  border-radius: 3px;
+  font-size: 11px;
+}
+.runProgressStrip .runProgressDone {
+  color: #1f513a;
+  font-weight: 600;
+}
+
 .runnerEvents {
   flex: 1;
   background: #2c2823;
@@ -2187,6 +2214,69 @@ a.iterationDiffToggle {
   font-family: ui-monospace, monospace;
 }
 
+/* Lifecycle state badge — replaces the old confidence number. The
+ * five state values get distinct backgrounds so a reviewer can scan
+ * the artifact list and immediately see which artifacts are accepted
+ * vs. deferred vs. waiting in provisional. */
+.artifactState {
+  padding: 2px 7px;
+  border-radius: 3px;
+  font-size: 10px;
+  font-weight: 700;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  border: 1px solid #c8b890;
+  background: #f3eada;
+  color: #6c604a;
+}
+.artifactState.state-accept {
+  background: #1f513a;
+  color: #fff;
+  border-color: #14392a;
+}
+.artifactState.state-cite_only {
+  background: #2a5279;
+  color: #fff;
+  border-color: #1c3955;
+}
+.artifactState.state-defer {
+  background: #d99032;
+  color: #fff;
+  border-color: #9c6724;
+}
+.artifactState.state-reject {
+  background: #6b3a36;
+  color: #fff;
+  border-color: #4a2825;
+}
+
+/* Critique severity badge: only renders on critique-kind artifacts
+ * once a severity is set. blocker / warning / minor map to red /
+ * orange / muted so a paper-quality scan is one glance. */
+.artifactSeverity {
+  padding: 2px 7px;
+  border-radius: 3px;
+  font-size: 10px;
+  font-weight: 700;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  border: 1px solid #c8b890;
+}
+.artifactSeverity.severity-blocker {
+  background: #8b2a17;
+  color: #fff;
+  border-color: #5a1d10;
+}
+.artifactSeverity.severity-warning {
+  background: #d99032;
+  color: #fff;
+  border-color: #9c6724;
+}
+.artifactSeverity.severity-minor {
+  background: #f3eada;
+  color: #6c604a;
+}
+
 .approvalBadge {
   margin-left: auto;
   padding: 2px 8px;

frontend/src/types.ts

@@ -24,7 +24,11 @@ export interface ResearchArtifact {
   assumptions: string[];
   evidence: string[];
   equations: string[];
-  confidence: number;
+  /** Legacy: bundled sampleRun still carries this for the demo replay's
+   *  fake "stats". Real artifacts coming from the API don't have it
+   *  — see ArtifactView in api/types.ts and the state machine in
+   *  src/halfseed/state/artifact_state.py for the replacement. */
+  confidence?: number;
   failure_modes: string[];
   next_steps: string[];
 }

frontend/src/utils/replay.ts

@@ -75,11 +75,16 @@ export function runStats(run: ResearchRun, architecture: LabArchitecture) {
   const riskCount =
     run.curated_report.open_risks.length +
     run.artifacts.reduce((total, artifact) => total + artifact.failure_modes.length, 0);
+  // confidence is optional now (bundled sampleRun keeps it; real
+  // artifacts use the structural state machine). Treat missing as 0
+  // — the avgConfidence number is only used by the demo replay HUD.
   const avgConfidence =
     run.artifacts.length === 0
       ? 0
-      : run.artifacts.reduce((total, artifact) => total + artifact.confidence, 0) /
-        run.artifacts.length;
+      : run.artifacts.reduce(
+          (total, artifact) => total + (artifact.confidence ?? 0),
+          0,
+        ) / run.artifacts.length;
 
   return {
     agents: architecture.agents.filter((agent) => agent.enabled).length,

frontend/src/views/ArtifactsView.tsx

@@ -134,7 +134,19 @@ function ArtifactCard({
           (expanded ? <ChevronDown size={14} /> : <ChevronRight size={14} />)}
         <span className="artifactAuthor">{artifact.author}</span>
         <span className="artifactKind">{artifact.kind}</span>
-        <span className="artifactConfidence">conf {artifact.confidence.toFixed(2)}</span>
+        {/* state replaces the old confidence float; severity is shown
+            for critique-kind artifacts when the system has assigned one
+            (blocker / warning / minor). See state/artifact_state.py. */}
+        {artifact.state && (
+          <span className={"artifactState state-" + artifact.state}>
+            {artifact.state}
+          </span>
+        )}
+        {artifact.severity && (
+          <span className={"artifactSeverity severity-" + artifact.severity}>
+            {artifact.severity}
+          </span>
+        )}
         <span className={"approvalBadge approval-" + artifact.approval_status}>
           {artifact.approval_status}
         </span>