gyoshu 0.2.5 → 0.3.0

package/AGENTS.md

@@ -573,6 +573,369 @@ print(f"[FINDING] Random Forest achieves {scores.mean():.1%} accuracy, "
       f"outperforming baseline by {improvement:.1%} (95% CI [{ci_low:.3f}, {ci_high:.3f}])")
 ```
 
+## Goal Contract System
+
+A **Goal Contract** defines measurable success criteria for research before execution begins. This enables Gyoshu to objectively determine whether a research goal has been achieved, rather than relying solely on subjective verification.
+
+### What is a Goal Contract?
+
+A Goal Contract is a formal specification that:
+1. **States the goal** in clear, measurable terms
+2. **Defines acceptance criteria** that must be met for success
+3. **Limits retry attempts** to prevent infinite loops
+4. **Enables automatic verification** at research completion
+
+### Goal Contract in Notebook Frontmatter
+
+Goal contracts are stored in the notebook's YAML frontmatter under the `gyoshu.goal_contract` key:
+
+```yaml
+---
+title: "Customer Churn Classification"
+gyoshu:
+  schema_version: 1
+  reportTitle: churn-classification
+  status: active
+  goal_contract:
+    version: 1
+    goal_text: "Build a classification model with 90% accuracy"
+    goal_type: "ml_classification"
+    max_goal_attempts: 3
+    acceptance_criteria:
+      - id: AC1
+        kind: metric_threshold
+        metric: cv_accuracy_mean
+        op: ">="
+        target: 0.90
+      - id: AC2
+        kind: marker_required
+        marker: "METRIC:baseline_accuracy"
+      - id: AC3
+        kind: artifact_exists
+        artifactPattern: "*.pkl"
+      - id: AC4
+        kind: finding_count
+        minCount: 3
+---
+```
+
+### Goal Contract Fields
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `version` | number | Yes | Schema version (currently `1`) |
+| `goal_text` | string | Yes | Human-readable goal statement |
+| `goal_type` | string | No | Goal category: `ml_classification`, `ml_regression`, `eda`, `statistical`, `custom` |
+| `max_goal_attempts` | number | No | Maximum pivot attempts before BLOCKED (default: 3) |
+| `acceptance_criteria` | array | Yes | List of criteria that must ALL pass |
+
+### Acceptance Criteria Types
+
+#### 1. `metric_threshold` — Compare Metric to Target
+
+Checks if a `[METRIC:name]` marker value meets a threshold.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `id` | string | Unique identifier (e.g., `AC1`) |
+| `kind` | string | Must be `metric_threshold` |
+| `metric` | string | Metric name (e.g., `cv_accuracy_mean`, `f1_score`) |
+| `op` | string | Comparison operator: `>=`, `>`, `<=`, `<`, `==` |
+| `target` | number | Target value to compare against |
+
+**Example:**
+```yaml
+- id: AC1
+  kind: metric_threshold
+  metric: cv_accuracy_mean
+  op: ">="
+  target: 0.90
+```
+
+**How it works:** Scans notebook output for `[METRIC:cv_accuracy_mean] 0.92` and checks if `0.92 >= 0.90`.
+
+#### 2. `marker_required` — Check Marker Exists
+
+Verifies that a specific marker type appears in the notebook output.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `id` | string | Unique identifier |
+| `kind` | string | Must be `marker_required` |
+| `marker` | string | Marker type to find (e.g., `METRIC:baseline_accuracy`, `STAT:ci`) |
+
+**Example:**
+```yaml
+- id: AC2
+  kind: marker_required
+  marker: "METRIC:baseline_accuracy"
+```
+
+**How it works:** Searches for `[METRIC:baseline_accuracy]` in any cell output. Passes if found at least once.
+
+#### 3. `artifact_exists` — Check File Exists
+
+Verifies that a specific artifact file was created in the reports directory.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `id` | string | Unique identifier |
+| `kind` | string | Must be `artifact_exists` |
+| `artifactPattern` | string | Glob pattern to match (e.g., `*.pkl`, `figures/*.png`, `model.joblib`) |
+
+**Example:**
+```yaml
+- id: AC3
+  kind: artifact_exists
+  artifactPattern: "models/*.pkl"
+```
+
+**How it works:** Checks `reports/{reportTitle}/models/` for any `.pkl` file. Passes if at least one match exists.
+
+#### 4. `finding_count` — Count Verified Findings
+
+Verifies that a minimum number of verified `[FINDING]` markers exist.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `id` | string | Unique identifier |
+| `kind` | string | Must be `finding_count` |
+| `minCount` | number | Minimum number of verified findings required |
+
+**Example:**
+```yaml
+- id: AC4
+  kind: finding_count
+  minCount: 3
+```
+
+**How it works:** Counts `[FINDING]` markers that have supporting `[STAT:ci]` and `[STAT:effect_size]` within 10 lines before. Only verified findings count.
+
+### Goal Contract Examples
+
+#### ML Classification Goal
+
+```yaml
+goal_contract:
+  version: 1
+  goal_text: "Classify wine quality with F1 >= 0.85"
+  goal_type: ml_classification
+  max_goal_attempts: 3
+  acceptance_criteria:
+    - id: AC1
+      kind: metric_threshold
+      metric: cv_f1_mean
+      op: ">="
+      target: 0.85
+    - id: AC2
+      kind: marker_required
+      marker: "METRIC:baseline_accuracy"
+    - id: AC3
+      kind: artifact_exists
+      artifactPattern: "models/*.pkl"
+```
+
+#### Exploratory Data Analysis Goal
+
+```yaml
+goal_contract:
+  version: 1
+  goal_text: "Complete comprehensive EDA with 5+ insights"
+  goal_type: eda
+  max_goal_attempts: 2
+  acceptance_criteria:
+    - id: AC1
+      kind: finding_count
+      minCount: 5
+    - id: AC2
+      kind: artifact_exists
+      artifactPattern: "figures/*.png"
+    - id: AC3
+      kind: marker_required
+      marker: "CONCLUSION"
+```
+
+#### Statistical Analysis Goal
+
+```yaml
+goal_contract:
+  version: 1
+  goal_text: "Test hypothesis with p < 0.05"
+  goal_type: statistical
+  max_goal_attempts: 2
+  acceptance_criteria:
+    - id: AC1
+      kind: marker_required
+      marker: "STAT:p_value"
+    - id: AC2
+      kind: marker_required
+      marker: "STAT:ci"
+    - id: AC3
+      kind: marker_required
+      marker: "STAT:effect_size"
+    - id: AC4
+      kind: finding_count
+      minCount: 1
+```
+
+## Two-Gate Completion
+
+Gyoshu uses a **Two-Gate verification system** to ensure both research quality (Trust Gate) and goal achievement (Goal Gate) before accepting results.
+
+### The Two Gates
+
+| Gate | What It Checks | Who Evaluates | Pass Condition |
+|------|----------------|---------------|----------------|
+| **Trust Gate** | Research quality, statistical rigor, evidence validity | Baksa (adversarial verifier) | Trust score ≥ 80 |
+| **Goal Gate** | Whether acceptance criteria are met | Automated (from goal contract) | All criteria pass |
+
+### Why Two Gates?
+
+**Trust Gate alone is insufficient:**
+- Research can be methodologically sound but fail to achieve the stated goal
+- Example: Perfect statistical analysis showing 70% accuracy when goal was 90%
+
+**Goal Gate alone is insufficient:**
+- Goal can be "achieved" through flawed methodology
+- Example: Claiming 95% accuracy on training set without cross-validation
+
+**Together, they ensure:**
+- Results are trustworthy AND meaningful
+- Claims are verified AND goals are met
+- Research is rigorous AND successful
+
+### Two-Gate Decision Matrix
+
+| Trust Gate | Goal Gate | Final Status | Action |
+|------------|-----------|--------------|--------|
+| ✅ PASS | ✅ MET | **SUCCESS** | Accept result, generate report |
+| ✅ PASS | ❌ NOT_MET | **PARTIAL** | Pivot: try different approach |
+| ✅ PASS | 🚫 BLOCKED | **BLOCKED** | Goal impossible, escalate to user |
+| ❌ FAIL | ✅ MET | **PARTIAL** | Rework: improve evidence quality |
+| ❌ FAIL | ❌ NOT_MET | **PARTIAL** | Rework: fix methodology |
+| ❌ FAIL | 🚫 BLOCKED | **BLOCKED** | Cannot proceed, escalate to user |
+
+### Gate Status Definitions
+
+**Trust Gate:**
+- `PASS`: Trust score ≥ 80 (verified)
+- `FAIL`: Trust score < 80 (needs rework)
+
+**Goal Gate:**
+- `MET`: All acceptance criteria pass
+- `NOT_MET`: Some criteria failed, but retry is possible
+- `BLOCKED`: Goal is impossible (e.g., data doesn't support the hypothesis)
+
+### The Pivot and Rework Cycle
+
+When gates fail, Gyoshu doesn't immediately give up:
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                      Research Execution                      │
+└─────────────────────────┬───────────────────────────────────┘
+                          ▼
+┌─────────────────────────────────────────────────────────────┐
+│                     Trust Gate Check                         │
+│               (Baksa adversarial verification)               │
+└───────────┬─────────────────────────────────┬───────────────┘
+            │ PASS                            │ FAIL
+            ▼                                 ▼
+┌───────────────────────┐         ┌───────────────────────────┐
+│   Goal Gate Check     │         │   Rework Request          │
+│ (Automated criteria)  │         │   (Fix evidence quality)  │
+└───────┬───────────────┘         └─────────────┬─────────────┘
+        │                                       │
+   MET  │  NOT_MET                              │
+        │     │                                 │
+        ▼     ▼                                 │
+   SUCCESS  PARTIAL                             │
+              │                                 │
+              ├───────── Attempt < Max? ────────┤
+              │              Yes                │
+              ▼                                 │
+        ┌─────────────┐                         │
+        │   PIVOT     │◄────────────────────────┘
+        │ Try new     │
+        │ approach    │
+        └─────────────┘
+              │
+              │ Attempt >= Max
+              ▼
+         BLOCKED
+```
+
+### Pivot vs Rework
+
+| Action | Trigger | What Happens |
+|--------|---------|--------------|
+| **Rework** | Trust Gate FAIL | Jogyo improves evidence (adds CI, effect size, etc.) without changing approach |
+| **Pivot** | Goal Gate NOT_MET | Jogyo tries a different approach (new model, different features, etc.) |
+
+### Max Attempts and BLOCKED Status
+
+The `max_goal_attempts` field in the goal contract limits how many times Gyoshu will try to achieve the goal:
+
+```yaml
+goal_contract:
+  max_goal_attempts: 3  # Try up to 3 different approaches
+```
+
+**Attempt counting:**
+- Each Pivot increments the attempt counter
+- Reworks do NOT increment (same approach, better evidence)
+- When attempts ≥ max_goal_attempts, status becomes BLOCKED
+
+**BLOCKED status means:**
+- The goal cannot be achieved with available data/methods
+- User intervention is required
+- Gyoshu will NOT keep trying indefinitely
+
+### Example: Two-Gate Flow
+
+**Goal:** "Build classifier with 90% accuracy"
+
+**Attempt 1:**
+1. Jogyo trains Random Forest → 85% accuracy
+2. Trust Gate: PASS (proper CV, baseline comparison)
+3. Goal Gate: NOT_MET (85% < 90%)
+4. Decision: PARTIAL → Pivot
+
+**Attempt 2:**
+1. Jogyo trains XGBoost → 92% accuracy
+2. Trust Gate: FAIL (no confidence interval reported)
+3. Decision: PARTIAL → Rework
+
+**Attempt 2 (Rework):**
+1. Jogyo adds CI: 95% CI [0.90, 0.94]
+2. Trust Gate: PASS
+3. Goal Gate: MET (92% ≥ 90%)
+4. Decision: **SUCCESS** ✅
+
+### Viewing Gate Results
+
+Gate results are included in the completion response:
+
+```json
+{
+  "status": "PARTIAL",
+  "trustGate": {
+    "passed": true,
+    "score": 85
+  },
+  "goalGate": {
+    "status": "NOT_MET",
+    "criteriaResults": [
+      { "id": "AC1", "passed": false, "actual": 0.85, "target": 0.90 },
+      { "id": "AC2", "passed": true }
+    ]
+  },
+  "action": "PIVOT",
+  "attemptNumber": 1,
+  "maxAttempts": 3
+}
+```
+
 ## Structured Output Markers
 
 When working with Gyoshu REPL output, use these markers:

package/README.md

@@ -39,6 +39,7 @@ Think of it like a research lab:
 - 📓 **Auto-Generated Notebooks** — Every experiment is captured as a reproducible `.ipynb`
 - 🤖 **Autonomous Mode** — Set a goal, walk away, come back to results
 - 🔍 **Adversarial Verification** — PhD reviewer challenges every claim before acceptance
+- 🎯 **Two-Gate Completion** — SUCCESS requires both evidence quality (Trust Gate) AND goal achievement (Goal Gate)
 - 📝 **AI-Powered Reports** — Turn messy outputs into polished research narratives
 - 🔄 **Session Management** — Continue, replay, or branch your research anytime
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gyoshu",
-  "version": "0.2.5",
+  "version": "0.3.0",
   "description": "Scientific research agent extension for OpenCode - turns research goals into reproducible Jupyter notebooks",
   "type": "module",
   "bin": {

package/src/agent/baksa.md

@@ -399,6 +399,87 @@ Each component is scored 0-100 based on challenges passed. Then apply:
 - **Rejection penalties**: -30 per automatic rejection trigger
 - **ML penalties**: -20 to -25 per ML violation (when applicable)
 
+## Goal Achievement Challenges (MANDATORY)
+
+The Trust Score evaluates **evidence quality** — whether claims are statistically sound and reproducible. But there's a separate question: **Did the results actually meet the stated goal?**
+
+These are two different gates:
+- **Trust Gate**: Is the evidence reliable? (Trust Score ≥ 80)
+- **Goal Gate**: Does the achieved outcome meet the acceptance criteria?
+
+**Both must pass for SUCCESS status.** High-quality evidence that fails to meet the goal is still a PARTIAL result.
+
+### Goal Achievement Questions
+
+For every completion claim, ask these questions:
+
+| Question | What You're Checking |
+|----------|---------------------|
+| \"What was the stated goal or target?\" | Extract the quantitative acceptance criteria |
+| \"What value was actually achieved?\" | Find the measured/computed result |
+| \"Does achieved meet or exceed target?\" | Compare: actual >= target? |
+| \"If claiming SUCCESS but target not met, why?\" | Challenge any mismatch |
+
+### Goal Achievement Challenge Protocol
+
+When reviewing a completion claim:
+
+1. **Extract the Goal**: Find the original objective with acceptance criteria
+   - Look for: \"90% accuracy\", \"p < 0.05\", \"reduce churn by 20%\", \"AUC > 0.85\"
+   - Goals may be in `[OBJECTIVE]` markers or session context
+
+2. **Extract the Achievement**: Find the actual measured results
+   - Look for: `[METRIC:*]` markers, `[STAT:*]` markers, final values
+   - Cross-reference with verification code outputs
+
+3. **Compare**: Does actual meet target?
+   - If YES: Goal Gate passes
+   - If NO: Goal Gate fails — cannot be SUCCESS status
+
+### Goal Achievement Mismatch Examples
+
+| Scenario | Goal | Achieved | Correct Status | Why |
+|----------|------|----------|----------------|-----|
+| Goal met | 90% accuracy | 92% accuracy | SUCCESS | Exceeds target |
+| Goal not met | 90% accuracy | 75% accuracy | PARTIAL | Below target despite good evidence |
+| Goal not met | p < 0.05 | p = 0.12 | PARTIAL | Failed statistical threshold |
+| Goal exceeded | AUC > 0.80 | AUC = 0.95 | SUCCESS | Significantly exceeds target |
+| No goal stated | \"analyze data\" | Analysis complete | SUCCESS | No quantitative target to miss |
+
+### Example Challenge Output
+
+When goal is NOT met but evidence is high-quality:
+
+```
+## GOAL ACHIEVEMENT CHALLENGE
+
+**Stated Goal**: \"Build classification model with >= 90% accuracy\"
+**Claimed Status**: SUCCESS
+**Achieved Metrics**:
+  - cv_accuracy_mean: 0.75
+  - cv_accuracy_std: 0.03
+
+**CHALLENGE**: The goal requires >= 90% accuracy, but achieved accuracy is 75% ± 3%.
+This does NOT meet the acceptance criteria.
+
+**Trust Score**: 85 (VERIFIED) — Evidence quality is excellent
+**Goal Gate**: FAILED — 75% < 90% target
+
+**Recommendation**: Status should be PARTIAL, not SUCCESS.
+Reason: High-quality work that did not achieve the stated objective.
+```
+
+### Goal vs Trust: Key Distinction
+
+| Aspect | Trust Gate | Goal Gate |
+|--------|------------|-----------|
+| **What it checks** | Evidence quality and rigor | Goal achievement |
+| **Score/Metric** | Trust Score (0-100) | Binary: Met/Not Met |
+| **Can fail independently** | Yes | Yes |
+| **Examples of failure** | Missing CI, no baseline | 75% accuracy when goal was 90% |
+
+**Critical Rule**: A researcher can do excellent, rigorous work (Trust = 90) and still fail to achieve the goal. This is PARTIAL, not SUCCESS. Both gates must pass for SUCCESS.
+
 ## Independent Verification Patterns
 
 When challenging claims, perform these verification checks:

package/src/agent/gyoshu.md

@@ -542,6 +542,186 @@ For backwards compatibility, you can still use researchId-based creation:
 2. Add a run with `research-manager` (action: addRun, runId: "run-xxx", data: {goal, mode})
 3. Initialize notebook with `notebook-writer` (action: ensure_notebook, notebookPath: "...")
 
+### Goal Contract Creation
+
+**CRITICAL**: Every research must have a **Goal Contract** that defines measurable acceptance criteria. The Goal Contract enables the **Two-Gate Verification System** — research cannot be marked SUCCESS without passing BOTH the Trust Gate (evidence quality) AND the Goal Gate (acceptance criteria met).
+
+#### Why Goal Contracts?
+
+Without a Goal Contract, research can be incorrectly marked SUCCESS when:
+- Evidence quality is high (Trust Gate passes), BUT
+- The actual goal was not achieved (e.g., "Build 90% accurate model" achieved 75%)
+
+The Goal Contract makes acceptance criteria **explicit and verifiable**.
+
+#### Goal Contract Format
+
+Include goal_contract in the notebook frontmatter or run configuration:
+
+```yaml
+gyoshu:
+  goal_contract:
+    version: 1
+    goal_text: "Build a churn prediction model with 90% accuracy"
+    goal_type: "ml_classification"       # ml_classification | ml_regression | statistical_test | eda | custom
+    max_goal_attempts: 3                  # Maximum pivots before BLOCKED
+    acceptance_criteria:
+      - id: AC1
+        kind: metric_threshold            # metric_threshold | artifact_exists | statistical_significance
+        metric: cv_accuracy_mean          # Must match a [METRIC:*] marker
+        op: ">="                          # >= | > | <= | < | == | !=
+        target: 0.90
+        
+      - id: AC2
+        kind: metric_threshold
+        metric: cv_accuracy_std
+        op: "<="
+        target: 0.05                      # Low variance required
+        
+      - id: AC3
+        kind: artifact_exists
+        artifact: "model.pkl"             # Must exist in reports/{reportTitle}/models/
+```
+
+#### Goal Contract Fields
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `version` | Yes | Schema version (currently: 1) |
+| `goal_text` | Yes | Human-readable goal statement |
+| `goal_type` | Yes | Category for validation rules |
+| `max_goal_attempts` | No | Max pivots before BLOCKED (default: 3) |
+| `acceptance_criteria` | Yes | List of verifiable criteria |
+
+#### Acceptance Criteria Kinds
+
+| Kind | Use When | Verification Method |
+|------|----------|---------------------|
+| `metric_threshold` | Numeric target (accuracy, R², etc.) | Compare `[METRIC:*]` marker value against target |
+| `artifact_exists` | Required output file | Check file exists in reports directory |
+| `statistical_significance` | Hypothesis testing | Verify p-value < alpha AND effect size reported |
+
+#### Two-Gate Decision Matrix
+
+**CRITICAL**: SUCCESS requires BOTH gates to pass. This is the core rule.
+
+| Trust Gate | Goal Gate | Result | Action |
+|------------|-----------|--------|--------|
+| PASS (≥80) | MET | **SUCCESS** | Accept result, finalize research |
+| PASS (≥80) | NOT_MET | **PARTIAL** | Pivot: try alternative approach |
+| PASS (≥80) | BLOCKED | **BLOCKED** | Cannot achieve goal, report to user |
+| FAIL (<80) | MET | **PARTIAL** | Rework: strengthen evidence |
+| FAIL (<80) | NOT_MET | **PARTIAL** | Rework both evidence and approach |
+| FAIL (<80) | BLOCKED | **BLOCKED** | Fundamental issue, escalate to user |
+
+**Gate Definitions:**
+- **Trust Gate**: Baksa verification score ≥ 80 (evidence quality)
+- **Goal Gate**: All acceptance_criteria in goal_contract are satisfied
+
+#### Goal Gate Evaluation
+
+After Trust Gate evaluation, check Goal Gate:
+
+```
+FUNCTION evaluateGoalGate(goalContract, snapshot):
+  FOR each criterion IN goalContract.acceptance_criteria:
+    
+    IF criterion.kind == "metric_threshold":
+      metricValue = findMetric(snapshot, criterion.metric)
+      IF NOT compare(metricValue, criterion.op, criterion.target):
+        RETURN { status: "NOT_MET", failed: criterion.id }
+    
+    ELSE IF criterion.kind == "artifact_exists":
+      IF NOT artifactExists(criterion.artifact):
+        RETURN { status: "NOT_MET", failed: criterion.id }
+    
+    ELSE IF criterion.kind == "statistical_significance":
+      IF NOT hasValidFinding(criterion):
+        RETURN { status: "NOT_MET", failed: criterion.id }
+  
+  RETURN { status: "MET" }
+```
+
+#### Pivot Protocol
+
+When Trust Gate PASSES but Goal Gate does NOT_MET:
+
+```
+PIVOT PROTOCOL (Trust ≥ 80, Goal NOT_MET):
+
+1. Increment goal_attempt counter
+2. IF goal_attempt >= max_goal_attempts:
+   → Status: BLOCKED
+   → Report: "Goal not achievable after {N} attempts"
+   → Present options to user
+
+3. ELSE:
+   → Status: PARTIAL
+   → Analyze WHY goal not met:
+     - Which criteria failed?
+     - What was the gap? (e.g., achieved 85% vs target 90%)
+     - What approaches were tried?
+   
+   → Generate pivot strategy:
+     - Alternative algorithm?
+     - More feature engineering?
+     - Relaxed criteria (with user approval)?
+     - Different data preprocessing?
+   
+   → Delegate to @jogyo with pivot context:
+     "PIVOT ATTEMPT {N}/{max}
+      Previous: XGBoost achieved 85% accuracy
+      Gap: 5% below 90% target
+      Try: Random Forest with hyperparameter tuning"
+```
+
+#### Example: Two-Gate Verification Flow
+
+```
+1. @jogyo completes model training
+   → Signals: gyoshu_completion(status: "SUCCESS", evidence: {...})
+
+2. Gyoshu gets snapshot
+   → gyoshu_snapshot(researchSessionID: "...")
+
+3. TRUST GATE: Invoke @baksa
+   → Trust Score: 85 (PASS ✓)
+   → Evidence quality verified
+
+4. GOAL GATE: Check acceptance criteria
+   → AC1: cv_accuracy_mean = 0.87 (target: 0.90) → FAIL
+   → Goal Gate: NOT_MET ✗
+
+5. TWO-GATE RESULT: Trust PASS + Goal NOT_MET = PARTIAL
+   → Do NOT mark SUCCESS
+   → Trigger PIVOT PROTOCOL
+
+6. PIVOT: Attempt 1/3
+   → Delegate to @jogyo with alternative approach
+   → "Try ensemble with feature selection"
+
+7. (Repeat verification after pivot...)
+
+8. FINAL: Trust PASS + Goal MET = SUCCESS
+   → Accept result, finalize research
+```
+
+#### Never Accept SUCCESS Without Goal Gate
+
+**HARD RULE**: Even with perfect evidence (Trust = 100), if acceptance criteria are not met, the result is PARTIAL, not SUCCESS.
+
+```
+❌ WRONG:
+   Trust: 95 (excellent evidence!)
+   Goal: 85% accuracy (target was 90%)
+   → "SUCCESS" // NO! Goal not met
+
+✓ CORRECT:
+   Trust: 95 (excellent evidence!)
+   Goal: 85% accuracy (target was 90%)
+   → "PARTIAL" → Pivot or report gap to user
+```
+
 ### Continuing Research
 
 When continuing existing research with notebook-centric workflow: