mindsystem-cc 3.13.0 → 3.13.1

package/agents/ms-mock-generator.md

@@ -1,182 +1,95 @@
 ---
 name: ms-mock-generator
-description: Generates framework-specific mock code for UAT testing. Spawned by verify-work when batch needs mocks.
+description: Generates inline mock edits in batch for UAT testing. Spawned by verify-work when 5+ mocks needed.
 model: sonnet
 tools: Read, Write, Edit, Bash, Grep, Glob
 color: cyan
 ---
 
 <role>
-You are a Mindsystem mock generator. You create framework-appropriate mock code for manual UI verification during UAT.
+You are a Mindsystem batch mock generator. You edit service/repository methods inline to hardcode return values for manual UAT testing.
 
-You are spawned by `/ms:verify-work` when a test batch requires mock state (error states, premium user, empty responses, loading states, etc.).
+Spawned by `/ms:verify-work` when a batch requires 5+ mocks — too many for main context to handle efficiently.
 
-Your job: Detect the framework, generate mock override files, add minimal production hooks if needed, and provide clear toggle instructions.
+Your job: Read each service method, edit it to return hardcoded values before the real implementation, and report what was changed.
 </role>
 
 <context_you_receive>
-Your prompt will include:
+Your prompt includes:
 
-- **Mock type needed**: The kind of state to mock (e.g., "error_state", "premium_user", "empty_response")
-- **Tests requiring this mock**: List of tests with their expected behaviors
+- **Tests requiring mocks**: List with mock_type and expected behavior for each
 - **Phase info**: Current phase being tested
+- **Mocked files so far**: Files already edited in previous batches (avoid conflicts)
 </context_you_receive>
 
-<framework_detection>
-**1. Check PROJECT.md first**
-```bash
-cat .planning/PROJECT.md 2>/dev/null | head -50
-```
+<references>
+@~/.claude/mindsystem/references/mock-patterns.md
+</references>
 
-Look for project type/stack description.
-
-**2. Verify with config files**
-```bash
-# Flutter/Dart
-ls pubspec.yaml 2>/dev/null
+<process>
 
-# React/Next.js
-ls package.json 2>/dev/null && grep -E '"react"|"next"' package.json
-
-# React Native
-ls package.json 2>/dev/null && grep '"react-native"' package.json
-
-# Vue
-ls package.json 2>/dev/null && grep '"vue"' package.json
-```
+**1. Identify service methods**
 
-**3. Determine framework**
-- Flutter: `pubspec.yaml` exists
-- React/Next.js: `package.json` with react/next dependency
-- React Native: `package.json` with react-native dependency
-- Vue: `package.json` with vue dependency
-- Other: Generate generic pattern with clear adaptation notes
-</framework_detection>
+For each test, identify the service/repository method that provides the data being tested. Use Grep to find fetch calls, API methods, or data access points related to the test's expected behavior.
 
-<mock_pattern>
-**Philosophy:** Mocks are temporary scaffolding. They should:
-- Be contained in as few files as possible (ideally 1 override file)
-- Have minimal hooks in production code (single if-check)
-- Be easy to completely remove (delete file + remove hooks)
+**2. Read and edit each method**
 
-**Pattern: Override File + Minimal Hooks**
-
-1. **Create override file** - Single file with all mock flags and data
-2. **Add minimal hooks** - If-check at service/repository layer
-3. **Provide toggle instructions** - How to enable/disable each state
-
-**Override file location conventions:**
-- Flutter: `lib/test_overrides.dart`
-- React/Next.js: `src/testOverrides.ts` or `lib/testOverrides.ts`
-- React Native: `src/testOverrides.ts`
-- Vue: `src/testOverrides.ts`
-</mock_pattern>
-
-<generation_process>
-**1. Analyze tests to determine mock requirements**
-
-For each test, identify:
-- What state needs to be simulated
-- What service/API call needs to be intercepted
-- What data should be returned
-
-**2. Create override file**
+For each method, add a hardcoded return/throw BEFORE the real implementation:
 
 ```
-# Pattern structure (adapt to framework):
-
-# Flags
-forcePremiumUser = false
-forceErrorState = false
-forceEmptyResponse = false
-forceLoadingState = false
+// MOCK: {description} — revert after UAT
+{hardcoded return value or throw}
 
-# Mock data (when flags are true)
-mockErrorMessage = "Simulated error for testing"
-mockPremiumUserData = { ... }
-
-# Reset function
-resetAllOverrides() { ... }
+// Real implementation below...
 ```
 
-**3. Identify hook points**
+**Patterns by mock_type:**
 
-Find the service/repository methods that need to check override flags.
-Add minimal hooks:
+| mock_type | Edit pattern |
+|-----------|-------------|
+| `error_state` | `throw Exception('{error message}');` before real call |
+| `empty_response` | `return [];` or `return null;` before real call |
+| `premium_user` | `return {hardcoded user object with premium fields};` |
+| `external_data` | `return {hardcoded data matching expected schema};` |
+| `loading_state` | `await {5s delay};` before real call |
+| `transient_state` | Delay or never-resolve — read `mock-patterns.md` transient_state_patterns |
+| `offline` | `throw {network error};` before real call |
 
-```
-# Pseudocode pattern:
-function getUserData() {
-  if (testOverrides.forcePremiumUser) {
-    return testOverrides.mockPremiumUserData
-  }
-  // ... real implementation
-}
-```
+**3. For transient_state mocks:** Read `mock-patterns.md` for delay injection and never-resolve strategies. Choose based on whether the test is verifying the transition or the loading UI appearance.
+
+**4. Track all changes**
 
-**4. Generate toggle instructions**
+Maintain a list of every file edited and what was changed.
 
-Clear steps for user:
-1. Which file to edit
-2. Which flag to set
-3. How to apply (hot reload, restart, etc.)
-4. How to verify mock is active
-</generation_process>
+</process>
 
 <return_format>
 ```markdown
-## MOCKS GENERATED
-
-**Framework detected:** {Flutter | React | etc.}
-**Mock type:** {the mock_type requested}
-
-### Files Created
-
-**{path/to/override_file}**
-- Purpose: Central mock control
-- Flags: {list of flags added}
+## Mocks Applied
 
-### Files Modified
+### Files Edited
 
-**{path/to/service_file}** (lines {N}-{M})
-- Added: Import for test overrides
-- Added: Override check in {method_name}
+| File | Method | Mock Type | Change |
+|------|--------|-----------|--------|
+| `{path}` | `{methodName}` | {type} | {brief description} |
 
-### Toggle Instructions
+### Cleanup
 
-**To enable {mock_state_1}:**
-1. Open `{override_file}`
-2. Set `{flag_name} = true`
-3. {Hot reload / Restart app}
-4. Verify: {what user should see to confirm mock is active}
-
-**To enable {mock_state_2}:**
-...
-
-### Reset
-
-To disable all mocks:
-1. Set all flags to `false` in `{override_file}`
-2. {Hot reload / Restart}
+To revert all mocks:
+```bash
+git checkout -- {space-separated list of files}
+```
 
-Or delete `{override_file}` entirely (hooks will use defaults).
+### Mocked Files List
+{JSON array of file paths for UAT.md frontmatter}
 ```
 </return_format>
 
 <constraints>
-- Keep override file as simple as possible
-- Minimize production code modifications
-- Don't create complex mock infrastructure
-- Don't modify test files (this is for manual UAT, not automated tests)
-- Include clear comments marking test-only code
-- Generated files should be .gitignore-able if needed
+- Edit existing methods only — do not create new files
+- Add mock code BEFORE the real implementation (early return pattern)
+- Mark every edit with `// MOCK: {description} — revert after UAT`
+- Do not modify test files — this is for manual UAT, not automated tests
+- Do not create override files or toggle flags — inline hardcoding only
+- Keep mock data minimal but realistic enough for UI rendering
 </constraints>
-
-<success_criteria>
-- [ ] Framework correctly detected
-- [ ] Override file created with appropriate flags
-- [ ] Minimal hooks added to production code (if needed)
-- [ ] Clear toggle instructions for each mock state
-- [ ] Reset instructions provided
-- [ ] All files written to disk (not just returned as content)
-</success_criteria>

package/commands/ms/verify-work.md

@@ -43,9 +43,9 @@ Phase: $ARGUMENTS (optional)
 4. **Extract testable deliverables** from summaries
 5. **Classify tests by mock requirements** — Use SUMMARY.md mock_hints when available; classify inline with keyword heuristics when absent. Confirm data availability with user before batching.
 6. **Group into batches** — By mock type, max 4 per batch, no-mock tests first
-   - If any tests require mocks: Read `~/.claude/mindsystem/references/mock-patterns.md` and `~/.claude/mindsystem/workflows/generate-mocks.md` for mock generation guidance
+   - If any tests require transient_state mocks: Read `~/.claude/mindsystem/references/mock-patterns.md` for delay strategies
 7. **For each batch:**
-   - If mock needed: Generate mocks, present toggle instructions, wait for confirmation
+   - If mock needed: Apply inline mocks (1-4 direct edits, 5+ via ms-mock-generator subagent), tell user to hot reload
    - Present tests via AskUserQuestion (Pass / Can't test / Skip / Other)
    - Process results, update UAT.md
    - **For each issue found:**
@@ -54,10 +54,10 @@ Phase: $ARGUMENTS (optional)
      - If complex: Spawn ms-verify-fixer subagent
      - 2 retries on failed re-test, then offer options
 8. **On batch transition:**
-   - If new mock_type: Discard old mocks, generate new ones
+   - If new mock_type: Revert old mocks (`git checkout -- <mocked_files>`), apply new ones
    - If same mock_type: Keep mocks active
 9. **On completion:**
-   - Discard all mocks (git stash drop)
+   - Revert all mocks (`git checkout -- <mocked_files>`)
    - Generate UAT fixes patch
    - Restore user's pre-existing work (if stashed)
    - Commit UAT.md, present summary
@@ -77,7 +77,7 @@ Phase: $ARGUMENTS (optional)
 - Don't run automated tests — this is manual user validation
 - Don't skip investigation — always try 2-3 tool calls before escalating
 - Don't fix complex issues inline — spawn fixer subagent for multi-file or architectural changes
-- Don't commit mock code — always stash before fixing
+- Don't commit mock code — stash mocked files before fixing, restore after
 - Don't re-present skipped tests — assumptions stand
 </anti_patterns>
 
@@ -85,14 +85,14 @@ Phase: $ARGUMENTS (optional)
 - [ ] Dirty tree handled at start (stash/commit/abort)
 - [ ] Tests extracted from SUMMARY.md and classified
 - [ ] Tests batched by mock requirements
-- [ ] Mocks generated when needed with clear toggle instructions
+- [ ] Mocks applied inline when needed (1-4 direct, 5+ via subagent)
 - [ ] Tests presented in batches of 4 using AskUserQuestion
 - [ ] Issues investigated with lightweight check first
 - [ ] Simple issues fixed inline with proper commit message
 - [ ] Complex issues escalated to fixer subagent
 - [ ] Failed re-tests get 2 retries then options
 - [ ] Stash conflicts auto-resolved to fix version
-- [ ] Mocks discarded on completion
+- [ ] Mocks reverted on completion (git checkout)
 - [ ] UAT fixes patch generated
 - [ ] User's pre-existing work restored
 - [ ] UAT.md committed with final summary

package/mindsystem/references/mock-patterns.md

@@ -1,21 +1,7 @@
 <overview>
-Mock patterns for manual UAT testing. Mocks are temporary scaffolding to reach testable UI states. They exist only as uncommitted changes — never in commit history.
+Mock patterns for manual UAT testing. Mocks are temporary inline edits to service methods — hardcoded return values that let you reach testable UI states. They exist only as uncommitted changes, never in commit history.
 </overview>
 
-<philosophy>
-**Mocks enable testing states you can't easily reach.**
-
-Without mocks, testing "error message display" requires actually triggering server errors. Testing "premium user badge" requires a premium account. Testing "empty list placeholder" requires deleting all data.
-
-**With mocks:** Set a flag, hot reload, test the UI state.
-
-**Core principles:**
-1. **Temporary** — Mocks are stashed/discarded, never committed
-2. **Minimal** — One override file, minimal production hooks
-3. **Explicit** — Clear flags, clear toggle instructions
-4. **Removable** — Delete file + remove imports = clean
-</philosophy>
-
 <classification_framework>
 
 **Two-question framework for mock classification:**
@@ -57,19 +43,161 @@ Domain terms don't map reliably to mock types. "View recipe list" needs external
 
 </classification_framework>
 
+<mock_types>
+
+| Mock Type | Enables Testing | Inline Pattern |
+|-----------|-----------------|----------------|
+| `error_state` | Error messages, retry UI, fallback displays | Throw exception before real implementation |
+| `premium_user` | Premium badges, gated features, upgrade prompts | Return mock user object with premium fields |
+| `empty_response` | Empty states, placeholder UI, "no results" | Return empty list/null before real implementation |
+| `loading_state` | Loading spinners, skeleton screens | Add delay before real implementation |
+| `offline` | Offline UI, cached data, sync indicators | Throw network error before real implementation |
+| `transient_state` | Brief async states (loading skeletons, transitions) | Delay or never-resolve strategies (see below) |
+| `external_data` | Features depending on API data that may not exist locally | Return hardcoded data objects |
+
+</mock_types>
+
+<inline_mock_patterns>
+
+**Inline mocks edit service methods directly.** Add hardcoded return values BEFORE the real implementation. Mark with `// MOCK:` comment for cleanup tracking.
+
+**Pattern:** Early return with mock comment
+```
+// MOCK: {description} — revert after UAT
+{hardcoded return/throw}
+
+// Real implementation below...
+```
+
+**By mock_type:**
+
+**error_state** — Throw before real call:
+```dart
+// Before:
+Future<User> login(String email, String password) async {
+  final response = await _api.post('/auth/login', data: {'email': email, 'password': password});
+  return User.fromJson(response.data);
+}
+
+// After:
+Future<User> login(String email, String password) async {
+  // MOCK: force login error — revert after UAT
+  throw Exception('Invalid credentials');
+
+  final response = await _api.post('/auth/login', data: {'email': email, 'password': password});
+  return User.fromJson(response.data);
+}
+```
+
+**empty_response** — Return empty collection:
+```dart
+// Before:
+Future<List<Recipe>> getRecipes() async {
+  final response = await _api.get('/recipes');
+  return response.data.map((j) => Recipe.fromJson(j)).toList();
+}
+
+// After:
+Future<List<Recipe>> getRecipes() async {
+  // MOCK: force empty list — revert after UAT
+  return [];
+
+  final response = await _api.get('/recipes');
+  return response.data.map((j) => Recipe.fromJson(j)).toList();
+}
+```
+
+**premium_user / external_data** — Return hardcoded object:
+```dart
+// Before:
+Future<User> getCurrentUser() async {
+  final response = await _api.get('/user/me');
+  return User.fromJson(response.data);
+}
+
+// After:
+Future<User> getCurrentUser() async {
+  // MOCK: force premium user — revert after UAT
+  return User(id: 'mock-001', name: 'Test User', isPremium: true, tier: 'gold');
+
+  final response = await _api.get('/user/me');
+  return User.fromJson(response.data);
+}
+```
+
+**TypeScript equivalents follow identical pattern** — early return/throw with `// MOCK:` comment before the real implementation.
+
+</inline_mock_patterns>
+
+<transient_state_patterns>
+
+**Transient states are UI states that appear briefly during async operations.** Loading skeletons, shimmer effects, transition animations — they resolve too fast to observe and test manually.
+
+**Two strategies:**
+
+**1. Extended delay (default):**
+
+Add a configurable delay before the real data returns. The transient state stays visible long enough to test.
+
+```dart
+// MOCK: extend loading state for testing — revert after UAT
+await Future.delayed(const Duration(seconds: 5));
+
+// Real implementation continues...
+final response = await _api.get('/recipes');
+return response.data.map((j) => Recipe.fromJson(j)).toList();
+```
+
+```typescript
+// MOCK: extend loading state for testing — revert after UAT
+await new Promise(resolve => setTimeout(resolve, 5000));
+
+// Real implementation continues...
+const response = await fetch('/api/recipes');
+return response.json();
+```
+
+**When to use:** Testing that the loading UI (skeleton, spinner) displays correctly while waiting.
+
+**2. Never-resolve:**
+
+The async call never completes. The transient state stays permanently visible.
+
+```dart
+// MOCK: freeze loading state — revert after UAT
+await Completer<void>().future; // Never completes
+
+// Real implementation continues...
+```
+
+```typescript
+// MOCK: freeze loading state — revert after UAT
+await new Promise(() => {}); // Never resolves
+
+// Real implementation continues...
+```
+
+**When to use:** Testing that the loading UI itself is correct (layout, styling, animation) without it disappearing.
+
+**Choosing between strategies:**
+- Testing the transition (loading → loaded): Use extended delay (5s default)
+- Testing the loading UI appearance: Use never-resolve
+
+</transient_state_patterns>
+
 <git_stash_lifecycle>
 
 **Why stash?**
 
-Fixes must be clean commits (no mock code). But after fixing, we need mocks back to re-test. Git stash enables this:
+Fixes must be clean commits (no mock code). But after fixing, mocks need to be restored to re-test. Git stash enables this:
 
 ```
 ┌─────────────────────────────────────────────────────────────┐
 │ Phase 1: Setup                                              │
 ├─────────────────────────────────────────────────────────────┤
 │ 1. git stash push -m "pre-verify-work" (if dirty)          │
-│ 2. Mock Generator creates mock code (uncommitted)           │
-│ 3. User confirms mocks look correct                         │
+│ 2. Inline mocks applied to service methods (uncommitted)    │
+│ 3. Mocked files tracked in UAT.md: mocked_files: [...]     │
 └─────────────────────────────────────────────────────────────┘
                               │
                               ▼
@@ -78,7 +206,7 @@ Fixes must be clean commits (no mock code). But after fixing, we need mocks back
 ├─────────────────────────────────────────────────────────────┤
 │ 4. User tests on device with mocks active                   │
 │ 5. User reports issue                                       │
-│ 6. git stash push -m "mocks-batch-N"  ← Stash mocks        │
+│ 6. git stash push -m "mocks-batch-N" -- <mocked_files>     │
 │ 7. Fixer investigates and commits fix  ← Clean commit      │
 │ 8. git stash pop                       ← Restore mocks     │
 │ 9. User re-tests specific item                             │
@@ -89,7 +217,7 @@ Fixes must be clean commits (no mock code). But after fixing, we need mocks back
 ┌─────────────────────────────────────────────────────────────┐
 │ Phase 3: Cleanup                                            │
 ├─────────────────────────────────────────────────────────────┤
-│ 11. git stash drop                     ← Discard mocks     │
+│ 11. git checkout -- <mocked_files>     ← Revert mocks      │
 │ 12. Generate UAT fixes patch                                │
 │ 13. git stash pop (if pre-existing)    ← Restore user work │
 └─────────────────────────────────────────────────────────────┘
@@ -97,7 +225,7 @@ Fixes must be clean commits (no mock code). But after fixing, we need mocks back
 
 **Stash naming convention:**
 - `pre-verify-work` — User's original uncommitted work
-- `mocks-batch-N` — Current mock state for batch N
+- `mocks-batch-N` — Current mock state for batch N (stashed only during fix application)
 
 </git_stash_lifecycle>
 
@@ -121,222 +249,3 @@ git add <conflicted-file>
 **This is rare.** Mocks typically live in data layer, fixes often in UI layer.
 
 </conflict_resolution>
-
-<flutter_example>
-
-**Override file: `lib/test_overrides.dart`**
-
-```dart
-// Test Overrides - DELETE THIS FILE BEFORE COMMITTING
-// Used for manual UAT testing only
-
-class TestOverrides {
-  // === STATE FLAGS ===
-  static bool forcePremiumUser = false;
-  static bool forceErrorState = false;
-  static bool forceEmptyResponse = false;
-  static bool forceLoadingState = false;
-  static bool forceTransientState = false;
-
-  // === MOCK DATA ===
-  static String mockErrorMessage = 'Simulated error for testing';
-  static Duration mockLoadingDelay = const Duration(seconds: 3);
-  static Duration mockTransientDelay = const Duration(seconds: 5);
-
-  static Map<String, dynamic> mockPremiumUser = {
-    'id': 'test-user-001',
-    'name': 'Test Premium User',
-    'isPremium': true,
-    'subscriptionTier': 'gold',
-  };
-
-  // === RESET ===
-  static void reset() {
-    forcePremiumUser = false;
-    forceErrorState = false;
-    forceEmptyResponse = false;
-    forceLoadingState = false;
-    forceTransientState = false;
-  }
-}
-```
-
-**Production hook: `lib/services/user_service.dart`**
-
-```dart
-import '../test_overrides.dart';
-
-class UserService {
-  Future<User> getCurrentUser() async {
-    // TEST OVERRIDE - Remove before commit
-    if (TestOverrides.forcePremiumUser) {
-      return User.fromJson(TestOverrides.mockPremiumUser);
-    }
-
-    // Real implementation
-    final response = await _api.get('/user/me');
-    return User.fromJson(response.data);
-  }
-
-  Future<List<Item>> getItems() async {
-    // TEST OVERRIDE - Remove before commit
-    if (TestOverrides.forceEmptyResponse) {
-      return [];
-    }
-    if (TestOverrides.forceErrorState) {
-      throw Exception(TestOverrides.mockErrorMessage);
-    }
-    // TEST OVERRIDE - Extend transient state (loading skeleton stays visible)
-    if (TestOverrides.forceTransientState) {
-      await Future.delayed(TestOverrides.mockTransientDelay);
-    }
-
-    // Real implementation
-    final response = await _api.get('/items');
-    return (response.data as List).map((j) => Item.fromJson(j)).toList();
-  }
-}
-```
-
-**Toggle instructions:**
-
-```
-To enable Premium User state:
-1. Open lib/test_overrides.dart
-2. Set TestOverrides.forcePremiumUser = true
-3. Hot reload (r in terminal)
-4. Verify: User profile shows "Premium" badge
-
-To enable Error State:
-1. Open lib/test_overrides.dart
-2. Set TestOverrides.forceErrorState = true
-3. Hot reload (r in terminal)
-4. Verify: Error message appears on relevant screens
-```
-
-</flutter_example>
-
-<react_example>
-
-**Override file: `src/testOverrides.ts`**
-
-```typescript
-// Test Overrides - DELETE THIS FILE BEFORE COMMITTING
-// Used for manual UAT testing only
-
-export const testOverrides = {
-  // === STATE FLAGS ===
-  forcePremiumUser: false,
-  forceErrorState: false,
-  forceEmptyResponse: false,
-  forceLoadingState: false,
-
-  // === MOCK DATA ===
-  mockErrorMessage: 'Simulated error for testing',
-  mockLoadingDelayMs: 3000,
-
-  mockPremiumUser: {
-    id: 'test-user-001',
-    name: 'Test Premium User',
-    isPremium: true,
-    subscriptionTier: 'gold',
-  },
-
-  // === RESET ===
-  reset() {
-    this.forcePremiumUser = false;
-    this.forceErrorState = false;
-    this.forceEmptyResponse = false;
-    this.forceLoadingState = false;
-  },
-};
-```
-
-**Production hook: `src/services/userService.ts`**
-
-```typescript
-import { testOverrides } from '../testOverrides';
-
-export async function getCurrentUser(): Promise<User> {
-  // TEST OVERRIDE - Remove before commit
-  if (testOverrides.forcePremiumUser) {
-    return testOverrides.mockPremiumUser as User;
-  }
-
-  // Real implementation
-  const response = await fetch('/api/user/me');
-  return response.json();
-}
-
-export async function getItems(): Promise<Item[]> {
-  // TEST OVERRIDE - Remove before commit
-  if (testOverrides.forceEmptyResponse) {
-    return [];
-  }
-  if (testOverrides.forceErrorState) {
-    throw new Error(testOverrides.mockErrorMessage);
-  }
-
-  // Real implementation
-  const response = await fetch('/api/items');
-  return response.json();
-}
-```
-
-**Toggle instructions:**
-
-```
-To enable Premium User state:
-1. Open src/testOverrides.ts
-2. Set forcePremiumUser: true
-3. Save file (auto hot reload in dev mode)
-4. Verify: User profile shows "Premium" badge
-
-To enable Error State:
-1. Open src/testOverrides.ts
-2. Set forceErrorState: true
-3. Save file (auto hot reload)
-4. Verify: Error message appears on relevant screens
-```
-
-</react_example>
-
-<best_practices>
-
-**Do:**
-- Keep all flags in one file
-- Use descriptive flag names (`forcePremiumUser` not `flag1`)
-- Add comments marking test-only code
-- Provide reset function
-- Document toggle instructions clearly
-
-**Don't:**
-- Create complex mock infrastructure
-- Add mocks in UI components (use service layer)
-- Commit mock code (ever)
-- Create multiple override files
-- Add conditional compilation / build flags
-
-**Signs you're over-engineering:**
-- More than one override file
-- Mock code in more than 3 production files
-- Complex mock data generators
-- Mocking at multiple layers simultaneously
-
-</best_practices>
-
-<cleanup>
-
-**After UAT complete:**
-
-1. `git stash drop` — Removes mock stash permanently
-2. Delete override file if still present
-3. Remove any imports/hooks still in production code
-
-**Verification:**
-```bash
-git status  # Should show no mock-related files
-grep -r "testOverrides" src/  # Should find nothing (or only the override file itself)
-```
-
-</cleanup>

package/mindsystem/templates/UAT.md

@@ -14,7 +14,7 @@ source: [list of SUMMARY.md files tested]
 started: [ISO timestamp]
 updated: [ISO timestamp]
 current_batch: [N]
-mock_stash: [stash name or null]
+mocked_files: []
 pre_work_stash: [stash name or null]
 ---
 
@@ -138,7 +138,7 @@ mock_type: empty_response
 - `started`: IMMUTABLE - set on creation
 - `updated`: OVERWRITE - update on every change
 - `current_batch`: OVERWRITE - current batch number
-- `mock_stash`: OVERWRITE - name of stashed mocks or null
+- `mocked_files`: OVERWRITE - list of files with inline mocks, or empty array
 - `pre_work_stash`: OVERWRITE - user's pre-existing work stash or null
 
 **Progress:**
@@ -196,23 +196,22 @@ mock_type: empty_response
 <mock_lifecycle>
 
 **When batch needs mocks:**
-1. Generate mock files (uncommitted)
-2. User enables mocks
-3. Testing proceeds
+1. Edit service methods inline (hardcoded return values)
+2. Record files in `mocked_files` frontmatter
+3. User hot reloads, testing proceeds
 
 **When fix needed:**
-1. `git stash push -m "mocks-batch-N"`
-2. Update `mock_stash` in frontmatter
-3. Fix applied, committed
-4. `git stash pop` to restore mocks
-5. Clear `mock_stash` if no conflicts
+1. `git stash push -m "mocks-batch-N" -- <mocked_files>`
+2. Fix applied, committed
+3. `git stash pop` to restore mocks
+4. If conflict: take fix version, remove file from `mocked_files`
 
 **On batch transition (different mock_type):**
-1. Discard old mocks: `git stash drop`
-2. Generate new mocks for new batch
+1. Revert old mocks: `git checkout -- <mocked_files>`
+2. Clear `mocked_files`, apply new inline mocks
 
 **On session complete:**
-1. Discard all mocks: `git stash drop`
+1. Revert all mocks: `git checkout -- <mocked_files>`
 2. Restore pre_work_stash if exists
 
 </mock_lifecycle>
@@ -225,8 +224,9 @@ On `/ms:verify-work` with existing UAT.md:
    - "complete" → offer to re-run or view results
    - "testing" or "fixing" → resume
 
-2. Check `mock_stash`:
-   - If exists, offer to restore or discard
+2. Check `mocked_files`:
+   - If non-empty, verify mocks still present via `git diff --name-only`
+   - If mocks lost, regenerate for current batch
 
 3. Check `current_batch`:
    - Resume from that batch
@@ -262,7 +262,7 @@ source: 04-01-SUMMARY.md, 04-02-SUMMARY.md
 started: 2025-01-15T10:30:00Z
 updated: 2025-01-15T11:15:00Z
 current_batch: 2
-mock_stash: mocks-batch-2
+mocked_files: [src/services/auth_service.dart, src/services/api_service.dart]
 pre_work_stash: null
 ---
 

package/mindsystem/workflows/verify-work.md

@@ -5,7 +5,7 @@ Complete verify-and-fix session: by session end, everything verified, issues fix
 </purpose>
 
 <execution_context>
-<!-- mock-patterns.md and generate-mocks.md loaded on demand when mocks are needed (see classify_tests step) -->
+<!-- mock-patterns.md loaded on demand for transient_state mocks (see generate_mocks step) -->
 </execution_context>
 
 <template>
@@ -232,7 +232,7 @@ tests:
 <step name="create_batches">
 **Group tests into batches:**
 
-**If any tests have mock_required=true:** Read `~/.claude/mindsystem/references/mock-patterns.md` and `~/.claude/mindsystem/workflows/generate-mocks.md` now for mock generation guidance.
+**If any tests have mock_required=true AND batch includes `transient_state` mocks:** Read `~/.claude/mindsystem/references/mock-patterns.md` for delay/never-resolve strategies.
 
 **Rules:**
 1. Group by mock_type (tests needing same mock state go together)
@@ -311,7 +311,7 @@ source: [list of SUMMARY.md files]
 started: [ISO timestamp]
 updated: [ISO timestamp]
 current_batch: 1
-mock_stash: null
+mocked_files: []
 pre_work_stash: [from dirty tree handling, or null]
 ---
 
@@ -378,11 +378,11 @@ Read current batch from UAT.md.
 **1. Handle mock generation (if needed):**
 
 If `mock_type` is not null AND different from previous batch:
-- Discard old mocks if any (use stash name from `mock_stash` in UAT.md frontmatter):
+- Revert old mocks if any (from `mocked_files` in UAT.md frontmatter):
   ```bash
-  MOCK_STASH=$(git stash list | grep "mocks-batch" | head -1 | cut -d: -f1)
-  [ -n "$MOCK_STASH" ] && git stash drop "$MOCK_STASH"
+  git checkout -- <mocked_files>
   ```
+- Clear `mocked_files` in frontmatter
 - Go to `generate_mocks`
 
 If `mock_type` is null or same as previous:
@@ -394,72 +394,61 @@ Go to `present_tests`
 </step>
 
 <step name="generate_mocks">
-**Generate mocks for current batch:**
+**Generate mocks for current batch using inline approach:**
 
-Present mock generation options:
-```
-## Batch [N]: [Name]
+Count mock-requiring tests in this batch.
 
-**Mock required:** [mock_type description]
+**Decision logic:**
 
-This batch tests states that require mock data. Options:
+| Count | Approach |
+|-------|----------|
+| 1-4   | Inline: edit service methods directly in main context |
+| 5+    | Subagent: spawn ms-mock-generator for batch editing |
 
-1. Generate mocks (Recommended) — I'll create the override files
-2. I'll set up mocks manually — Skip generation, you handle it
-3. Skip this batch — Log all tests as assumptions
-```
+**Inline approach (1-4 mocks):**
 
-**If "Generate mocks":**
+For each test in the batch:
+1. Identify the service/repository method that provides the data
+2. Read the method
+3. Edit to hardcode desired return value BEFORE the real implementation:
+   ```
+   // MOCK: {description} — revert after UAT
+   {hardcoded return/throw}
+   ```
+4. For transient_state mocks: Read `~/.claude/mindsystem/references/mock-patterns.md` for delay/never-resolve strategies
+
+**Subagent approach (5+ mocks):**
 
-Spawn mock generator:
 ```
 Task(
   prompt="""
-Generate mocks for manual UAT testing.
+Generate inline mocks for manual UAT testing.
 
-Project: {from PROJECT.md}
 Phase: {phase_name}
-Mock type: {mock_type}
 
-Tests requiring this mock:
-{test list with expected behaviors}
+Tests requiring mocks:
+{test list with mock_type and expected behaviors}
 
-Follow patterns from @~/.claude/mindsystem/workflows/generate-mocks.md
+Mocked files from previous batches (avoid conflicts):
+{mocked_files from UAT.md frontmatter}
 """,
   subagent_type="ms-mock-generator",
   description="Generate {mock_type} mocks"
 )
 ```
 
-After mock generator returns:
+**After mocks applied (both approaches):**
 
-1. Update UAT.md: `mock_stash: null` (mocks are uncommitted, not stashed yet)
-2. Present toggle instructions from mock generator
-3. Ask user to confirm mocks are active:
+1. Record mocked files in UAT.md frontmatter: `mocked_files: [file1.dart, file2.dart, ...]`
+2. Tell user: "Mocks applied. Hot reload to test."
+3. Proceed directly to `present_tests` — no user confirmation needed
 
-```
-questions:
-  - question: "I've created the mock files. Have you enabled the mocks and verified they're working?"
-    header: "Mocks ready"
-    options:
-      - label: "Yes, mocks are active"
-        description: "I've toggled the flags and hot reloaded"
-      - label: "Having trouble"
-        description: "Something isn't working with the mocks"
-    multiSelect: false
-```
-
-**If "I'll set up manually":**
-- Present what mock state is needed
-- Wait for user to confirm ready
+**Skip option:**
 
-**If "Skip this batch":**
-- Prompt for reason: "Why are you skipping this batch?"
-- Mark all tests in batch as `skipped` with user's reason
+If user has previously indicated they want to skip mock batches, or if mock generation fails:
+- Mark all tests in batch as `skipped`
 - Append to Assumptions section
 - Proceed to next batch
-
-Proceed to `present_tests`.
 </step>
 
 <step name="present_tests">
@@ -574,9 +563,9 @@ For each question:
 
 **1. Stash mocks (if active):**
 ```bash
-git stash push -m "mocks-batch-{N}"
+git stash push -m "mocks-batch-{N}" -- <mocked_files>
 ```
-Update UAT.md: `mock_stash: "mocks-batch-{N}"`
+Use `mocked_files` list from UAT.md frontmatter.
 
 **2. Make the fix:**
 - Edit the file(s)
@@ -605,11 +594,11 @@ git stash pop
 
 **Handle stash conflict:**
 ```bash
-# If conflict, take fix version
+# Conflict means fix touched a mocked file — take the fix version
 git checkout --theirs <conflicted-file>
 git add <conflicted-file>
 ```
-Log that mock was discarded for that file.
+Remove conflicted file from `mocked_files` list in UAT.md (mock no longer needed for that file).
 
 **6. Request re-test:**
 ```
@@ -626,7 +615,7 @@ Go to `handle_retest`.
 
 **1. Stash mocks (if active):**
 ```bash
-git stash push -m "mocks-batch-{N}"
+git stash push -m "mocks-batch-{N}" -- <mocked_files>
 ```
 
 **2. Spawn ms-verify-fixer:**
@@ -738,13 +727,12 @@ questions:
 
 Read full UAT file.
 
-Check `mock_stash` — if exists, offer to restore:
-```
-Found stashed mocks: {mock_stash}
-
-1. Restore mocks — Continue where we left off
-2. Discard mocks — Start batch fresh
+Check `mocked_files` — if non-empty, verify mocks are still present:
+```bash
+git diff --name-only
 ```
+If mocked files have uncommitted changes, mocks are still active — continue.
+If mocked files are clean, mocks were lost — regenerate for current batch.
 
 Find current position:
 - current_batch
@@ -796,12 +784,11 @@ issues: {count}
 <step name="complete_session">
 **Complete UAT session:**
 
-**1. Discard mocks:**
+**1. Revert mocks:**
 ```bash
-# Find and drop the specific mock stash (not just the top one)
-MOCK_STASH=$(git stash list | grep "mocks-batch" | head -1 | cut -d: -f1)
-[ -n "$MOCK_STASH" ] && git stash drop "$MOCK_STASH"
+git checkout -- <mocked_files>
 ```
+Use `mocked_files` list from UAT.md frontmatter. Clear the list after reverting.
 
 **2. Generate UAT fixes patch (if fixes were made):**
 ```bash
@@ -818,7 +805,7 @@ PRE_WORK_STASH=$(git stash list | grep "pre-verify-work" | head -1 | cut -d: -f1
 
 **4. Update UAT.md:**
 - status: complete
-- Clear current_batch, mock_stash
+- Clear current_batch, mocked_files
 - Final Progress counts
 
 **5. Commit UAT.md:**
@@ -863,7 +850,7 @@ Check if more phases remain in ROADMAP.md:
 |---------|------|------|
 | Frontmatter.status | OVERWRITE | Phase transitions |
 | Frontmatter.current_batch | OVERWRITE | Batch transitions |
-| Frontmatter.mock_stash | OVERWRITE | Stash operations |
+| Frontmatter.mocked_files | OVERWRITE | Mock generation/cleanup |
 | Frontmatter.updated | OVERWRITE | Every write |
 | Progress | OVERWRITE | After each test result |
 | Current Batch | OVERWRITE | Batch transitions |
@@ -895,7 +882,7 @@ Default: **major** (safe default)
 - [ ] Dirty tree handled at start
 - [ ] Tests classified by mock requirements
 - [ ] Batches created respecting dependencies and mock types
-- [ ] Mocks generated when needed with toggle instructions
+- [ ] Mocks applied inline when needed (1-4 direct, 5+ via subagent)
 - [ ] Tests presented in batches of 4
 - [ ] Issues investigated with lightweight check (2-3 calls)
 - [ ] Simple issues fixed inline with proper commit
@@ -903,7 +890,7 @@ Default: **major** (safe default)
 - [ ] Re-test retries (2 max, tracked via retry_count) before offering options
 - [ ] Blocked tests re-presented after blocking issues resolved
 - [ ] Stash conflicts auto-resolved to fix version
-- [ ] Mocks discarded on completion
+- [ ] Mocks reverted on completion (git checkout)
 - [ ] UAT fixes patch generated
 - [ ] User's pre-existing work restored
 - [ ] UAT.md committed with final summary

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindsystem-cc",
-  "version": "3.13.0",
+  "version": "3.13.1",
   "description": "A meta-prompting, context engineering and spec-driven development system for Claude Code by TÂCHES.",
   "bin": {
     "mindsystem-cc": "bin/install.js"

package/mindsystem/workflows/generate-mocks.md

@@ -1,261 +0,0 @@
-<purpose>
-Generate framework-specific mock code for manual UAT testing. Creates override files with toggle flags and minimal production hooks.
-
-Called by verify-work workflow when a test batch requires mock state.
-</purpose>
-
-<philosophy>
-**Mocks are temporary scaffolding.**
-
-They exist only as uncommitted changes during testing. They enable reaching UI states that require specific backend conditions (premium user, error states, empty lists, loading states).
-
-**Principles:**
-- Minimal footprint: One override file + minimal hooks
-- Easy removal: Delete file, remove imports, done
-- Framework-appropriate: Match project conventions
-- User-controlled: Clear toggle instructions
-</philosophy>
-
-<framework_detection>
-
-**Step 1: Read PROJECT.md**
-```bash
-cat .planning/PROJECT.md 2>/dev/null | head -50
-```
-
-**Step 2: Verify with config files**
-
-| Check | Indicates |
-|-------|-----------|
-| `pubspec.yaml` exists | Flutter |
-| `package.json` has `"react"` or `"next"` | React/Next.js |
-| `package.json` has `"react-native"` | React Native |
-| `package.json` has `"vue"` | Vue |
-
-**Step 3: Determine file locations**
-
-| Framework | Override File | Import Pattern |
-|-----------|---------------|----------------|
-| Flutter | `lib/test_overrides.dart` | `import 'package:{app}/test_overrides.dart';` |
-| React/Next.js | `src/testOverrides.ts` | `import { testOverrides } from '@/testOverrides';` |
-| React Native | `src/testOverrides.ts` | `import { testOverrides } from '../testOverrides';` |
-| Vue | `src/testOverrides.ts` | `import { testOverrides } from '@/testOverrides';` |
-
-</framework_detection>
-
-<override_file_pattern>
-
-**Structure:**
-
-```
-// Test Overrides - DELETE THIS FILE BEFORE COMMITTING
-// Used for manual UAT testing only
-
-// === STATE FLAGS ===
-// Set to true to enable mock state
-
-{flag declarations based on mock_type}
-
-// === MOCK DATA ===
-// Returned when flags are true
-
-{mock data structures}
-
-// === RESET ===
-// Call to disable all overrides
-
-{reset function}
-```
-
-**Flag naming convention:**
-- `force{State}` for boolean flags (e.g., `forcePremiumUser`, `forceErrorState`)
-- `mock{DataType}` for mock data (e.g., `mockUserData`, `mockErrorMessage`)
-
-</override_file_pattern>
-
-<production_hook_pattern>
-
-**Minimal hooks at service/repository layer:**
-
-```
-// Check override BEFORE real implementation
-if (testOverrides.force{State}) {
-  return testOverrides.mock{Data};
-}
-
-// Real implementation continues here...
-```
-
-**Placement:**
-- In services/repositories, not UI components
-- At the data fetch point, not the render point
-- Single if-check, no complex branching
-
-**Marking:**
-```
-// TEST OVERRIDE - Remove before commit
-if (testOverrides.forceError) {
-  throw testOverrides.mockError;
-}
-```
-
-</production_hook_pattern>
-
-<mock_types>
-
-Common mock types and what they enable:
-
-| Mock Type | Enables Testing | Typical Flags |
-|-----------|-----------------|---------------|
-| `error_state` | Error messages, retry UI, fallback displays | `forceError`, `mockErrorMessage` |
-| `premium_user` | Premium badges, gated features, upgrade prompts | `forcePremium`, `mockPremiumData` |
-| `empty_response` | Empty states, placeholder UI, "no results" | `forceEmpty` |
-| `loading_state` | Loading spinners, skeleton screens | `forceLoading`, `mockLoadingDelay` |
-| `offline` | Offline UI, cached data, sync indicators | `forceOffline` |
-| `transient_state` | Brief async states (loading skeletons, transitions) | `forceTransient`, `mockTransientDelay` |
-| `external_data` | Features depending on API data that may not exist locally | `forceMockData`, `mockDataSet` |
-
-</mock_types>
-
-<transient_state_patterns>
-
-**Transient states are UI states that appear briefly during async operations.** Loading skeletons, shimmer effects, transition animations — they resolve too fast to observe and test manually.
-
-**Two mock strategies:**
-
-**1. Extended delay strategy (default):**
-
-Add a configurable delay before the real data returns. The transient state stays visible long enough to test.
-
-```dart
-// Flutter — Completer-based delay
-Future<List<Recipe>> getRecipes() async {
-  // TEST OVERRIDE - Extend loading state for testing
-  if (TestOverrides.forceTransientState) {
-    await Future.delayed(TestOverrides.mockTransientDelay); // default 5s
-  }
-  // Real implementation continues...
-  final response = await _api.get('/recipes');
-  return response.data.map((j) => Recipe.fromJson(j)).toList();
-}
-```
-
-```typescript
-// React/Next.js — Promise delay
-async function getRecipes(): Promise<Recipe[]> {
-  // TEST OVERRIDE - Extend loading state for testing
-  if (testOverrides.forceTransientState) {
-    await new Promise(resolve => setTimeout(resolve, testOverrides.mockTransientDelayMs));
-  }
-  // Real implementation continues...
-  const response = await fetch('/api/recipes');
-  return response.json();
-}
-```
-
-**When to use:** Testing that the loading UI (skeleton, spinner) displays correctly while waiting.
-
-**2. Never-resolve strategy:**
-
-The async call never completes. The transient state stays permanently visible.
-
-```dart
-// Flutter — Completer that never completes
-Future<List<Recipe>> getRecipes() async {
-  // TEST OVERRIDE - Never resolve, keep loading state visible
-  if (TestOverrides.forceTransientState && TestOverrides.mockTransientDelay == Duration.zero) {
-    await Completer<void>().future; // Never completes
-  }
-  // Real implementation continues...
-}
-```
-
-```typescript
-// JS — Promise that never resolves
-async function getRecipes(): Promise<Recipe[]> {
-  // TEST OVERRIDE - Never resolve, keep loading state visible
-  if (testOverrides.forceTransientState && testOverrides.mockTransientDelayMs === 0) {
-    await new Promise(() => {}); // Never resolves
-  }
-  // Real implementation continues...
-}
-```
-
-**When to use:** Testing that the loading UI itself is correct (layout, styling, animation) without it disappearing.
-
-**Choosing between strategies:**
-- Testing the transition (loading → loaded): Use extended delay (5s default)
-- Testing the loading UI appearance: Use never-resolve (set delay to 0)
-
-</transient_state_patterns>
-
-<toggle_instructions_template>
-
-**Format for each mock state:**
-
-```markdown
-**To enable {state_name}:**
-1. Open `{override_file_path}`
-2. Set `{flag_name} = true`
-3. {Hot reload command or restart instruction}
-4. Verify: {What user should see to confirm mock is active}
-
-**To disable:**
-1. Set `{flag_name} = false`
-2. {Hot reload / restart}
-```
-
-**Framework-specific apply instructions:**
-
-| Framework | Apply Changes |
-|-----------|---------------|
-| Flutter | Hot reload (r in terminal) or hot restart (R) |
-| React/Next.js (dev) | Auto hot reload on save |
-| React Native | Shake device → Reload, or `r` in Metro |
-| Vue (dev) | Auto hot reload on save |
-
-</toggle_instructions_template>
-
-<spawn_mock_generator>
-
-When verify-work needs mocks:
-
-```
-Task(
-  prompt="""
-You are generating test mocks for manual UI verification.
-
-## Context
-
-Project type: {detected_framework}
-Phase: {phase_name}
-Mock type needed: {mock_type}
-
-## Tests requiring this mock
-
-{test_list_with_expected_behavior}
-
-## Requirements
-
-1. Create override file at standard location for this framework
-2. Add minimal hooks to relevant services (if needed)
-3. Provide clear toggle instructions
-4. Write all files to disk
-
-Follow the patterns from @~/.claude/mindsystem/workflows/generate-mocks.md
-""",
-  subagent_type="ms-mock-generator",
-  description="Generate {mock_type} mocks"
-)
-```
-
-</spawn_mock_generator>
-
-<success_criteria>
-- [ ] Framework correctly detected
-- [ ] Override file created at standard location
-- [ ] Minimal hooks added (only if needed)
-- [ ] Toggle instructions clear and complete
-- [ ] Files written to disk (uncommitted)
-- [ ] Easy to remove (clear cleanup path)
-</success_criteria>