agent-bober 0.5.1 → 0.6.0

package/README.md

@@ -451,15 +451,20 @@ To debug failing E2E tests:
 
 This architecture implements the patterns described in Anthropic's [**"Harness design for long-running application development"**](https://www.anthropic.com/engineering/harness-design-long-running-apps) by Prithvi Rajasekaran. The key insight from that research: separating code generation from code evaluation creates a feedback loop that catches errors early and dramatically improves output quality. In their tests, a solo agent produced broken output in 20 minutes, while the full harness produced a polished, working application — demonstrating that multi-agent orchestration with honest evaluation is worth the investment.
 
-- **Planner** (Claude Opus): High-reasoning model for decomposing complex features into clear, testable sprint contracts. Thinks about scope, dependencies, and risk.
-- **Generator** (Claude Sonnet): Fast, capable model for writing code. Works within the boundaries of a single sprint contract.
-- **Evaluator** (Claude Sonnet): Runs automated checks (typecheck, lint, build, tests) and provides structured feedback. If a sprint fails evaluation, the Generator gets specific rework instructions.
+### Agentic Tool-Use Architecture
+
+Each agent runs as a **multi-turn agentic loop** with tool access via the Anthropic SDK. System prompts are loaded from the detailed agent definitions in `agents/bober-*.md` (300-600 lines of role-specific instructions, anti-leniency protocols, and evaluation criteria).
+
+- **Planner** (Claude Opus): Explores the codebase via read-only tools (`read_file`, `glob`, `grep`), then produces sprint-decomposed plans. Thinks about scope, dependencies, and risk.
+- **Generator** (Claude Sonnet): Full tool access (`bash`, `read_file`, `write_file`, `edit_file`, `glob`, `grep`). Reads existing code, writes implementation, runs tests, and commits — all autonomously within the sprint contract boundaries.
+- **Evaluator** (Claude Sonnet): Read-only + bash tools (`bash`, `read_file`, `glob`, `grep` — deliberately NO write/edit). Independently verifies by running the dev server, taking Playwright screenshots, executing tests, and inspecting code. Cannot fix bugs — only report them with precise feedback.
 
 The separation ensures that:
-1. The Generator cannot "mark its own homework" -- an independent evaluation step catches issues.
+1. The Generator cannot "mark its own homework" — an independent evaluation step with its own tool access catches issues through actual runtime verification, not just reading the generator's self-report.
 2. Sprint contracts provide clear scope boundaries, preventing feature creep.
-3. Automated checks run after every sprint, not just at the end.
+3. Automated checks (programmatic evaluators) + agent-based qualitative evaluation run after every sprint.
 4. Context resets between sprints keep the Generator focused and prevent context degradation.
+5. The Evaluator's anti-leniency protocol ensures passing on the first iteration is rare for non-trivial work.
 
 ### State Management
 
@@ -522,10 +527,11 @@ agent-bober/
     config/           Config schema, loader, defaults
     contracts/        Sprint contract and eval result types
     evaluators/       Built-in evaluator plugins
-    orchestrator/     Context handoff and agent coordination
+    orchestrator/     Agent runners, agentic loop, tool infrastructure
+      tools/          Tool schemas, sandboxed handlers, role-based sets
     state/            State management for .bober/ directory
     utils/            Shared utilities
-  agents/             Agent system prompts (.md files)
+  agents/             Agent system prompts (.md files, loaded at runtime)
   skills/             Claude Code slash command definitions
   templates/          Project templates and scaffolds
   hooks/              Claude Code hooks

package/agents/bober-evaluator.md

@@ -88,9 +88,59 @@ Read these documents in order:
 
 Build a checklist from the contract's `successCriteria` array. This is your evaluation framework. Every criterion gets tested independently.
 
-### Step 2: Run Configured Evaluation Strategies
+### Step 2: Live Page Evaluation (for frontend/UI projects)
 
-Read `evaluator.strategies` from `bober.config.json`. Execute each configured strategy in order.
+**Before running ANY automated strategy**, if this sprint involves UI/frontend changes, you MUST interact with the live page. This is NOT optional. This is the FIRST thing you do.
+
+**2a. Start the dev server:**
+```bash
+npm run dev &
+DEV_PID=$!
+sleep 8
+```
+
+**2b. Screenshot and study the page:**
+```bash
+npx playwright screenshot http://localhost:3000 /tmp/bober-eval-home.png --full-page 2>&1
+```
+Screenshot additional routes relevant to this sprint. READ every screenshot — you are multimodal, you can see images.
+
+**2c. Score against the four design criteria.**
+
+Study each screenshot carefully, then score each criterion 0-100. Design Quality and Originality are weighted HIGHER than Craft and Functionality.
+
+**Design Quality** (Weight: High) — Does the design feel like a coherent whole? Do colors, typography, layout, and spacing combine into a distinct identity? Or does it look like random parts assembled together?
+- Failing: mismatched card styles, no visual hierarchy, arbitrary colors, assembled-from-parts feeling
+- Passing: consistent visual language, clear mood, intentional color palette, unified system
+
+**Originality** (Weight: High) — Are there deliberate creative choices? Or is this default templates and AI-generated patterns?
+- Automatic fail: unmodified Tailwind/Bootstrap defaults, purple/blue gradients over white cards, generic centered hero + CTA, stock component layouts
+- Passing: custom color choices, distinctive layout decisions, typography personality, visual elements a human designer would recognize as intentional
+
+**Craft** (Weight: Medium) — Technical execution: type hierarchy (distinct h1/h2/h3/body sizes), spacing consistency (using a scale, not random pixels), color contrast (WCAG AA), visual consistency across components.
+
+**Functionality** (Weight: Medium) — Can users find primary actions? Are interactive elements obvious? Are loading/error/empty states handled?
+
+**Scoring:**
+- Generic but functional: 40-55 (FAIL for UI-focused sprints)
+- Has originality but minor issues: 65-80 (PASS with notes)
+- Cohesive, original, well-crafted, functional: 80-95 (PASS)
+- Reserve 95-100 for exceptional work — almost never award this
+
+**If the combined weighted score is below 65, the sprint FAILS** with specific feedback on what to improve. Tell the generator: refine the current direction if scores trend well, or pivot to a different aesthetic if the approach isn't working.
+
+**2d. Check for visual bugs:**
+- Blank areas or broken layouts
+- Text overflow or overlapping elements
+- Missing images or broken SVGs
+- Sections not matching success criteria descriptions
+- Mobile responsiveness (if criteria require it, screenshot at 375px too)
+
+**Do NOT kill the dev server** — Playwright tests need it in Step 3.
+
+### Step 3: Run Configured Evaluation Strategies
+
+Read `evaluator.strategies` from `bober.config.json`. Execute each configured strategy in order. **The dev server should still be running from Step 2.**
 
 **For each strategy, record:**
 - Strategy type
@@ -99,6 +149,11 @@ Read `evaluator.strategies` from `bober.config.json`. Execute each configured st
 - Pass/fail determination
 - Whether this strategy is `required` (blocking) or optional
 
+**After all strategies are done, kill the dev server:**
+```bash
+kill $DEV_PID 2>/dev/null
+```
+
 **Strategy execution:**
 
 #### `typecheck`
@@ -187,7 +242,7 @@ This strategy requires careful execution:
 - Execute the custom command specified
 - Interpret output based on the strategy's config
 
-### Step 3: Verify Success Criteria
+### Step 4: Verify Success Criteria
 
 Go through EVERY success criterion in the contract, one by one. For each:
 
@@ -202,7 +257,7 @@ Go through EVERY success criterion in the contract, one by one. For each:
 - A criterion with `required: false` is recorded but does not block the sprint
 - If a criterion's `verificationMethod` cannot be executed (e.g., Playwright not set up), mark it as `"skipped"` with a clear reason. If it was `required`, escalate this as a configuration issue.
 
-### Step 4: Check Principles Adherence
+### Step 5: Check Principles Adherence
 
 If `.bober/principles.md` exists, verify the Generator's output adheres to the project principles:
 
@@ -212,7 +267,7 @@ If `.bober/principles.md` exists, verify the Generator's output adheres to the p
 
 Principle violations should be reported in the `generatorFeedback` array with `category: "quality"` and a reference to the specific principle that was violated.
 
-### Step 5: Check for Regressions
+### Step 6: Check for Regressions
 
 Beyond the contract's criteria, check for regressions:
 
@@ -220,7 +275,7 @@ Beyond the contract's criteria, check for regressions:
 2. **Does the build still work?** Even if the contract is about backend code, verify the full build.
 3. **Were any existing files modified in unexpected ways?** Use `git diff` to review all changes. Flag any changes to files NOT mentioned in the contract's `estimatedFiles`.
 
-### Step 6: Produce Structured EvalResult
+### Step 7: Produce Structured EvalResult
 
 Generate the following JSON structure:
 
@@ -282,7 +337,7 @@ Generate the following JSON structure:
 }
 ```
 
-### Step 7: Save and Report
+### Step 8: Save and Report
 
 1. **Save the EvalResult** to `.bober/eval-results/<evalId>.json`
    - IMPORTANT: You do not have Write tools. Output the EvalResult JSON and the orchestrator will save it.
@@ -471,53 +526,6 @@ If `playwright` is in the configured evaluation strategies:
    ```
    New interactive elements without `data-testid` = quality failure with feedback to add them.
 
-## Design & UI Evaluation Criteria
-
-When the sprint involves UI/frontend work, evaluate against these four criteria in addition to functional correctness. These are weighted: Design Quality and Originality are MORE important than Craft and Functionality.
-
-### 1. Design Quality (Weight: High)
-Does the design feel like a coherent whole rather than a collection of parts? Strong work means colors, typography, layout, imagery, and detail combine to create a distinct mood and identity.
-
-**Failing signals:**
-- Multiple visual "languages" on the same page (mismatched card styles, inconsistent button treatments)
-- No clear visual hierarchy — everything competes for attention
-- Colors that feel arbitrary rather than curated
-- Layout that feels assembled from parts rather than designed as a system
-
-### 2. Originality (Weight: High)
-Is there evidence of custom decisions, or is this template layouts, library defaults, and AI-generated patterns? A human designer should recognize deliberate creative choices.
-
-**Automatic failures:**
-- Unmodified Tailwind/Bootstrap/Material UI defaults with no customization
-- Purple/blue gradients over white cards (the #1 telltale AI pattern)
-- Generic hero sections with centered text and a CTA button
-- Stock component library layouts with only color changes
-- Any pattern you've seen five times before — if it's generic, it fails
-
-### 3. Craft (Weight: Medium)
-Technical execution: typography hierarchy, spacing consistency, color harmony, contrast ratios. This is a competence check.
-
-**Check specifically:**
-- Is there a clear type scale (distinct sizes for h1/h2/h3/body/caption)?
-- Is spacing consistent (using a scale like 4/8/16/24/32/48, not random pixels)?
-- Do colors have sufficient contrast for accessibility (WCAG AA minimum)?
-- Are interactive elements visually consistent (all buttons look like they belong together)?
-
-### 4. Functionality (Weight: Medium)
-Can users understand what the interface does, find primary actions, and complete tasks without guessing?
-
-**Check specifically:**
-- Are primary actions visually prominent?
-- Do interactive elements have clear hover/focus/active states?
-- Are loading, error, and empty states handled?
-- Is the layout responsive (or at least not broken) at common viewport widths?
-
-### Scoring UI Work
-- A design that is technically correct but visually generic scores LOW (40-55)
-- A design with originality and craft but minor functional issues scores MEDIUM-HIGH (65-80)
-- A design that is cohesive, original, well-crafted, AND functional scores HIGH (80-95)
-- Reserve 95-100 for genuinely exceptional work — you should almost never award this
-
 ## Code Quality Evaluation
 
 Beyond functional correctness, evaluate code quality ruthlessly:

package/agents/bober-generator.md

@@ -399,3 +399,7 @@ When implementing user interfaces, your work will be graded on four criteria. Yo
 4. **Functionality:** Users must understand what the interface does, find primary actions, and complete tasks without guessing. Interactive elements must have clear affordances. Loading states, error states, and empty states must all be handled.
 
 Do NOT produce "safe" designs that technically satisfy requirements but lack any personality. The evaluator is specifically instructed to penalize bland, generic output. Take aesthetic risks. Make deliberate choices about color, typography, layout, and motion.
+
+**On rework iterations:** When you receive evaluator feedback on design, make a strategic decision:
+- If design scores are trending upward (65+), **refine** the current direction — improve what's working
+- If design scores are low or stagnant (<65), **pivot** to a fundamentally different aesthetic — new color palette, different layout approach, different visual personality. Don't polish something that isn't working.

package/dist/contracts/eval-result.d.ts

@@ -24,6 +24,69 @@ export declare const EvalDetailSchema: z.ZodObject<{
     line?: number | undefined;
 }>;
 export type EvalDetail = z.infer<typeof EvalDetailSchema>;
+export declare const CriterionResultSchema: z.ZodObject<{
+    criterionId: z.ZodString;
+    description: z.ZodString;
+    required: z.ZodBoolean;
+    result: z.ZodEnum<["pass", "fail", "skipped"]>;
+    evidence: z.ZodOptional<z.ZodString>;
+    feedback: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    required: boolean;
+    criterionId: string;
+    result: "pass" | "fail" | "skipped";
+    feedback?: string | undefined;
+    evidence?: string | undefined;
+}, {
+    description: string;
+    required: boolean;
+    criterionId: string;
+    result: "pass" | "fail" | "skipped";
+    feedback?: string | undefined;
+    evidence?: string | undefined;
+}>;
+export type CriterionResult = z.infer<typeof CriterionResultSchema>;
+export declare const RegressionSchema: z.ZodObject<{
+    description: z.ZodString;
+    evidence: z.ZodString;
+    severity: z.ZodEnum<["critical", "major", "minor"]>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    severity: "critical" | "major" | "minor";
+    evidence: string;
+}, {
+    description: string;
+    severity: "critical" | "major" | "minor";
+    evidence: string;
+}>;
+export type Regression = z.infer<typeof RegressionSchema>;
+export declare const GeneratorFeedbackItemSchema: z.ZodObject<{
+    priority: z.ZodEnum<["critical", "high", "medium", "low"]>;
+    category: z.ZodEnum<["bug", "missing-feature", "regression", "quality", "performance"]>;
+    file: z.ZodOptional<z.ZodString>;
+    line: z.ZodOptional<z.ZodNumber>;
+    description: z.ZodString;
+    expected: z.ZodOptional<z.ZodString>;
+    reproduction: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    priority: "medium" | "critical" | "high" | "low";
+    category: "bug" | "missing-feature" | "regression" | "quality" | "performance";
+    expected?: string | undefined;
+    file?: string | undefined;
+    line?: number | undefined;
+    reproduction?: string | undefined;
+}, {
+    description: string;
+    priority: "medium" | "critical" | "high" | "low";
+    category: "bug" | "missing-feature" | "regression" | "quality" | "performance";
+    expected?: string | undefined;
+    file?: string | undefined;
+    line?: number | undefined;
+    reproduction?: string | undefined;
+}>;
+export type GeneratorFeedbackItem = z.infer<typeof GeneratorFeedbackItemSchema>;
 export declare const EvalResultSchema: z.ZodObject<{
     evaluator: z.ZodString;
     passed: z.ZodBoolean;
@@ -53,6 +116,69 @@ export declare const EvalResultSchema: z.ZodObject<{
     summary: z.ZodString;
     feedback: z.ZodString;
     timestamp: z.ZodString;
+    iteration: z.ZodOptional<z.ZodNumber>;
+    contractId: z.ZodOptional<z.ZodString>;
+    criteriaResults: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        criterionId: z.ZodString;
+        description: z.ZodString;
+        required: z.ZodBoolean;
+        result: z.ZodEnum<["pass", "fail", "skipped"]>;
+        evidence: z.ZodOptional<z.ZodString>;
+        feedback: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        required: boolean;
+        criterionId: string;
+        result: "pass" | "fail" | "skipped";
+        feedback?: string | undefined;
+        evidence?: string | undefined;
+    }, {
+        description: string;
+        required: boolean;
+        criterionId: string;
+        result: "pass" | "fail" | "skipped";
+        feedback?: string | undefined;
+        evidence?: string | undefined;
+    }>, "many">>;
+    regressions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        description: z.ZodString;
+        evidence: z.ZodString;
+        severity: z.ZodEnum<["critical", "major", "minor"]>;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        severity: "critical" | "major" | "minor";
+        evidence: string;
+    }, {
+        description: string;
+        severity: "critical" | "major" | "minor";
+        evidence: string;
+    }>, "many">>;
+    designScore: z.ZodOptional<z.ZodNumber>;
+    generatorFeedback: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        priority: z.ZodEnum<["critical", "high", "medium", "low"]>;
+        category: z.ZodEnum<["bug", "missing-feature", "regression", "quality", "performance"]>;
+        file: z.ZodOptional<z.ZodString>;
+        line: z.ZodOptional<z.ZodNumber>;
+        description: z.ZodString;
+        expected: z.ZodOptional<z.ZodString>;
+        reproduction: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        priority: "medium" | "critical" | "high" | "low";
+        category: "bug" | "missing-feature" | "regression" | "quality" | "performance";
+        expected?: string | undefined;
+        file?: string | undefined;
+        line?: number | undefined;
+        reproduction?: string | undefined;
+    }, {
+        description: string;
+        priority: "medium" | "critical" | "high" | "low";
+        category: "bug" | "missing-feature" | "regression" | "quality" | "performance";
+        expected?: string | undefined;
+        file?: string | undefined;
+        line?: number | undefined;
+        reproduction?: string | undefined;
+    }>, "many">>;
 }, "strip", z.ZodTypeAny, {
     evaluator: string;
     passed: boolean;
@@ -68,6 +194,31 @@ export declare const EvalResultSchema: z.ZodObject<{
     summary: string;
     feedback: string;
     score?: number | undefined;
+    iteration?: number | undefined;
+    contractId?: string | undefined;
+    criteriaResults?: {
+        description: string;
+        required: boolean;
+        criterionId: string;
+        result: "pass" | "fail" | "skipped";
+        feedback?: string | undefined;
+        evidence?: string | undefined;
+    }[] | undefined;
+    regressions?: {
+        description: string;
+        severity: "critical" | "major" | "minor";
+        evidence: string;
+    }[] | undefined;
+    designScore?: number | undefined;
+    generatorFeedback?: {
+        description: string;
+        priority: "medium" | "critical" | "high" | "low";
+        category: "bug" | "missing-feature" | "regression" | "quality" | "performance";
+        expected?: string | undefined;
+        file?: string | undefined;
+        line?: number | undefined;
+        reproduction?: string | undefined;
+    }[] | undefined;
 }, {
     evaluator: string;
     passed: boolean;
@@ -83,6 +234,31 @@ export declare const EvalResultSchema: z.ZodObject<{
     summary: string;
     feedback: string;
     score?: number | undefined;
+    iteration?: number | undefined;
+    contractId?: string | undefined;
+    criteriaResults?: {
+        description: string;
+        required: boolean;
+        criterionId: string;
+        result: "pass" | "fail" | "skipped";
+        feedback?: string | undefined;
+        evidence?: string | undefined;
+    }[] | undefined;
+    regressions?: {
+        description: string;
+        severity: "critical" | "major" | "minor";
+        evidence: string;
+    }[] | undefined;
+    designScore?: number | undefined;
+    generatorFeedback?: {
+        description: string;
+        priority: "medium" | "critical" | "high" | "low";
+        category: "bug" | "missing-feature" | "regression" | "quality" | "performance";
+        expected?: string | undefined;
+        file?: string | undefined;
+        line?: number | undefined;
+        reproduction?: string | undefined;
+    }[] | undefined;
 }>;
 export type EvalResult = z.infer<typeof EvalResultSchema>;
 export declare const SprintEvaluationSchema: z.ZodObject<{
@@ -117,6 +293,69 @@ export declare const SprintEvaluationSchema: z.ZodObject<{
         summary: z.ZodString;
         feedback: z.ZodString;
         timestamp: z.ZodString;
+        iteration: z.ZodOptional<z.ZodNumber>;
+        contractId: z.ZodOptional<z.ZodString>;
+        criteriaResults: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            criterionId: z.ZodString;
+            description: z.ZodString;
+            required: z.ZodBoolean;
+            result: z.ZodEnum<["pass", "fail", "skipped"]>;
+            evidence: z.ZodOptional<z.ZodString>;
+            feedback: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            description: string;
+            required: boolean;
+            criterionId: string;
+            result: "pass" | "fail" | "skipped";
+            feedback?: string | undefined;
+            evidence?: string | undefined;
+        }, {
+            description: string;
+            required: boolean;
+            criterionId: string;
+            result: "pass" | "fail" | "skipped";
+            feedback?: string | undefined;
+            evidence?: string | undefined;
+        }>, "many">>;
+        regressions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            description: z.ZodString;
+            evidence: z.ZodString;
+            severity: z.ZodEnum<["critical", "major", "minor"]>;
+        }, "strip", z.ZodTypeAny, {
+            description: string;
+            severity: "critical" | "major" | "minor";
+            evidence: string;
+        }, {
+            description: string;
+            severity: "critical" | "major" | "minor";
+            evidence: string;
+        }>, "many">>;
+        designScore: z.ZodOptional<z.ZodNumber>;
+        generatorFeedback: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            priority: z.ZodEnum<["critical", "high", "medium", "low"]>;
+            category: z.ZodEnum<["bug", "missing-feature", "regression", "quality", "performance"]>;
+            file: z.ZodOptional<z.ZodString>;
+            line: z.ZodOptional<z.ZodNumber>;
+            description: z.ZodString;
+            expected: z.ZodOptional<z.ZodString>;
+            reproduction: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            description: string;
+            priority: "medium" | "critical" | "high" | "low";
+            category: "bug" | "missing-feature" | "regression" | "quality" | "performance";
+            expected?: string | undefined;
+            file?: string | undefined;
+            line?: number | undefined;
+            reproduction?: string | undefined;
+        }, {
+            description: string;
+            priority: "medium" | "critical" | "high" | "low";
+            category: "bug" | "missing-feature" | "regression" | "quality" | "performance";
+            expected?: string | undefined;
+            file?: string | undefined;
+            line?: number | undefined;
+            reproduction?: string | undefined;
+        }>, "many">>;
     }, "strip", z.ZodTypeAny, {
         evaluator: string;
         passed: boolean;
@@ -132,6 +371,31 @@ export declare const SprintEvaluationSchema: z.ZodObject<{
         summary: string;
         feedback: string;
         score?: number | undefined;
+        iteration?: number | undefined;
+        contractId?: string | undefined;
+        criteriaResults?: {
+            description: string;
+            required: boolean;
+            criterionId: string;
+            result: "pass" | "fail" | "skipped";
+            feedback?: string | undefined;
+            evidence?: string | undefined;
+        }[] | undefined;
+        regressions?: {
+            description: string;
+            severity: "critical" | "major" | "minor";
+            evidence: string;
+        }[] | undefined;
+        designScore?: number | undefined;
+        generatorFeedback?: {
+            description: string;
+            priority: "medium" | "critical" | "high" | "low";
+            category: "bug" | "missing-feature" | "regression" | "quality" | "performance";
+            expected?: string | undefined;
+            file?: string | undefined;
+            line?: number | undefined;
+            reproduction?: string | undefined;
+        }[] | undefined;
     }, {
         evaluator: string;
         passed: boolean;
@@ -147,6 +411,31 @@ export declare const SprintEvaluationSchema: z.ZodObject<{
         summary: string;
         feedback: string;
         score?: number | undefined;
+        iteration?: number | undefined;
+        contractId?: string | undefined;
+        criteriaResults?: {
+            description: string;
+            required: boolean;
+            criterionId: string;
+            result: "pass" | "fail" | "skipped";
+            feedback?: string | undefined;
+            evidence?: string | undefined;
+        }[] | undefined;
+        regressions?: {
+            description: string;
+            severity: "critical" | "major" | "minor";
+            evidence: string;
+        }[] | undefined;
+        designScore?: number | undefined;
+        generatorFeedback?: {
+            description: string;
+            priority: "medium" | "critical" | "high" | "low";
+            category: "bug" | "missing-feature" | "regression" | "quality" | "performance";
+            expected?: string | undefined;
+            file?: string | undefined;
+            line?: number | undefined;
+            reproduction?: string | undefined;
+        }[] | undefined;
     }>, "many">;
     overallPassed: z.ZodBoolean;
     aggregateFeedback: z.ZodString;
@@ -168,6 +457,31 @@ export declare const SprintEvaluationSchema: z.ZodObject<{
         summary: string;
         feedback: string;
         score?: number | undefined;
+        iteration?: number | undefined;
+        contractId?: string | undefined;
+        criteriaResults?: {
+            description: string;
+            required: boolean;
+            criterionId: string;
+            result: "pass" | "fail" | "skipped";
+            feedback?: string | undefined;
+            evidence?: string | undefined;
+        }[] | undefined;
+        regressions?: {
+            description: string;
+            severity: "critical" | "major" | "minor";
+            evidence: string;
+        }[] | undefined;
+        designScore?: number | undefined;
+        generatorFeedback?: {
+            description: string;
+            priority: "medium" | "critical" | "high" | "low";
+            category: "bug" | "missing-feature" | "regression" | "quality" | "performance";
+            expected?: string | undefined;
+            file?: string | undefined;
+            line?: number | undefined;
+            reproduction?: string | undefined;
+        }[] | undefined;
     }[];
     overallPassed: boolean;
     aggregateFeedback: string;
@@ -189,6 +503,31 @@ export declare const SprintEvaluationSchema: z.ZodObject<{
         summary: string;
         feedback: string;
         score?: number | undefined;
+        iteration?: number | undefined;
+        contractId?: string | undefined;
+        criteriaResults?: {
+            description: string;
+            required: boolean;
+            criterionId: string;
+            result: "pass" | "fail" | "skipped";
+            feedback?: string | undefined;
+            evidence?: string | undefined;
+        }[] | undefined;
+        regressions?: {
+            description: string;
+            severity: "critical" | "major" | "minor";
+            evidence: string;
+        }[] | undefined;
+        designScore?: number | undefined;
+        generatorFeedback?: {
+            description: string;
+            priority: "medium" | "critical" | "high" | "low";
+            category: "bug" | "missing-feature" | "regression" | "quality" | "performance";
+            expected?: string | undefined;
+            file?: string | undefined;
+            line?: number | undefined;
+            reproduction?: string | undefined;
+        }[] | undefined;
     }[];
     overallPassed: boolean;
     aggregateFeedback: string;

package/dist/contracts/eval-result.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"eval-result.d.ts","sourceRoot":"","sources":["../../src/contracts/eval-result.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,cAAc,yCAAuC,CAAC;AACnE,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAItD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;EAO3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAI1D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQ3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAI1D,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMjC,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAItE;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,UAAU,EAAE,GACpB,gBAAgB,CAsBlB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,gBAAgB,GAAG,MAAM,CA2CnE"}
+{"version":3,"file":"eval-result.d.ts","sourceRoot":"","sources":["../../src/contracts/eval-result.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,cAAc,yCAAuC,CAAC;AACnE,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAItD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;EAO3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAI1D,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;EAOhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;EAI3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;EActC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CACzC,OAAO,2BAA2B,CACnC,CAAC;AAIF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAe3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAI1D,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMjC,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAItE;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,UAAU,EAAE,GACpB,gBAAgB,CAsBlB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,gBAAgB,GAAG,MAAM,CA2CnE"}