igny8/STAGE_4_PLAN.md

STAGE 4 REFACTOR PLAN — DDAY Completion

Plan Date: November 26, 2025
Author: AI Agent (Claude Sonnet 4.5)
Objective: Complete 100% of original DDAY refactor specifications
Based On: REFACTOR_GAP_ANALYSIS.md — 20 identified gaps

---

🎯 STAGE 4 MISSION

Primary Goal: Close all gaps between original DDAY specs and current implementation to achieve 100% spec compliance.

Success Criteria:

• ✅ All 20 identified gaps resolved
• ✅ Batch cluster/taxonomy assignment functional
• ✅ Sites module UI cleaned (builder buttons removed)
• ✅ All deprecated field references eliminated
• ✅ Content Manager is true "single source of truth"
• ✅ Full end-to-end workflow verified

Estimated Effort: 2-3 days
Priority: HIGH (blocking complete refactor sign-off)

---

📋 PHASE BREAKDOWN

Phase 1: Critical Features (Blocking Completion) — 1 day

Goal: Implement missing core spec requirements
Deliverables:

• Batch cluster assignment
• Batch taxonomy assignment
• Sites module cleanup

Phase 2: Backend Cleanup & Validation — 0.5 days

Goal: Remove deprecated references, add validations
Deliverables:

• Filter cleanup
• Publish validation
• Management command updates

Phase 3: Frontend Polish & UX — 0.5-1 day

Goal: Finalize UI, remove broken components
Deliverables:

• PostEditor refactor
• ToggleTableRow cleanup
• Test updates

Phase 4: Verification & Documentation — 0.5 days

Goal: Full E2E testing and docs update
Deliverables:

• Complete workflow tests
• Updated STAGE_4_COMPLETE.md
• CHANGELOG.md entry

---

🔴 PHASE 1: CRITICAL FEATURES (Day 1)

1.1 Backend — Bulk Update Endpoint

File: backend/igny8_core/modules/writer/serializers.py

Create new serializer:

class BulkUpdateContentSerializer(serializers.Serializer):
    """Serializer for bulk updating content records"""
    content_ids = serializers.ListField(
        child=serializers.IntegerField(),
        required=True,
        help_text="List of Content IDs to update"
    )
    cluster_id = serializers.IntegerField(
        required=False,
        allow_null=True,
        help_text="Cluster ID to assign to selected content"
    )
    taxonomy_term_ids = serializers.ListField(
        child=serializers.IntegerField(),
        required=False,
        help_text="Taxonomy term IDs to attach to selected content"
    )
    
    def validate_content_ids(self, value):
        if not value:
            raise serializers.ValidationError("At least one content ID required")
        if len(value) > 100:
            raise serializers.ValidationError("Maximum 100 items per batch")
        return value
    
    def validate(self, data):
        if not data.get('cluster_id') and not data.get('taxonomy_term_ids'):
            raise serializers.ValidationError(
                "Must provide cluster_id or taxonomy_term_ids"
            )
        return data

File: backend/igny8_core/modules/writer/views.py

Add to ContentViewSet:

from rest_framework.decorators import action
from rest_framework.response import Response
from django.db import transaction

class ContentViewSet(SiteSectorModelViewSet):
    # ... existing code ...
    
    @action(detail=False, methods=['patch'], url_path='bulk-update')
    def bulk_update(self, request):
        """
        Bulk update cluster and/or taxonomy assignments
        
        POST /api/v1/writer/content/bulk-update/
        {
            "content_ids": [1, 2, 3],
            "cluster_id": 5,  // optional
            "taxonomy_term_ids": [10, 11]  // optional
        }
        """
        serializer = BulkUpdateContentSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        
        content_ids = serializer.validated_data['content_ids']
        cluster_id = serializer.validated_data.get('cluster_id')
        taxonomy_term_ids = serializer.validated_data.get('taxonomy_term_ids', [])
        
        # Verify user has access to this site's content
        queryset = self.get_queryset()
        content_items = queryset.filter(id__in=content_ids)
        
        if content_items.count() != len(content_ids):
            return Response({
                'success': False,
                'error': 'Some content items not found or not accessible'
            }, status=400)
        
        updated_count = 0
        errors = []
        
        with transaction.atomic():
            for content in content_items:
                try:
                    if cluster_id:
                        from igny8_core.business.planning.models import Clusters
                        cluster = Clusters.objects.get(id=cluster_id, site=content.site)
                        content.cluster = cluster
                    
                    if taxonomy_term_ids:
                        # Replace existing terms with new selection
                        content.taxonomy_terms.set(taxonomy_term_ids)
                    
                    content.save()
                    updated_count += 1
                    
                except Exception as e:
                    errors.append({
                        'content_id': content.id,
                        'error': str(e)
                    })
        
        return Response({
            'success': True,
            'updated': updated_count,
            'errors': errors,
            'message': f'Successfully updated {updated_count} content items'
        })

File: backend/igny8_core/modules/writer/urls.py

No changes needed (action decorator auto-registers route)

---

1.2 Frontend — Bulk Assignment UI

File: frontend/src/config/pages/content.config.tsx

Add selection column:

import { Checkbox } from '@/components/ui/checkbox';

export const contentTableConfig = {
  columns: [
    {
      id: 'select',
      header: ({ table }) => (
        <Checkbox
          checked={table.getIsAllPageRowsSelected()}
          onCheckedChange={(value) => table.toggleAllPageRowsSelected(!!value)}
          aria-label="Select all"
        />
      ),
      cell: ({ row }) => (
        <Checkbox
          checked={row.getIsSelected()}
          onCheckedChange={(value) => row.toggleSelected(!!value)}
          aria-label="Select row"
        />
      ),
      enableSorting: false,
      enableHiding: false,
    },
    // ... existing columns ...
  ],
  // ... rest of config ...
};

File: frontend/src/services/api.ts

Add bulk update function:

export interface BulkUpdateContentRequest {
  content_ids: number[];
  cluster_id?: number;
  taxonomy_term_ids?: number[];
}

export interface BulkUpdateContentResponse {
  success: boolean;
  updated: number;
  errors: Array<{ content_id: number; error: string }>;
  message: string;
}

export const bulkUpdateContent = async (
  data: BulkUpdateContentRequest
): Promise<BulkUpdateContentResponse> => {
  const response = await apiClient.patch<BulkUpdateContentResponse>(
    '/api/v1/writer/content/bulk-update/',
    data
  );
  return response.data;
};

File: frontend/src/pages/Writer/Content.tsx

Add bulk operations UI:

import { useState } from 'react';
import { bulkUpdateContent } from '@/services/api';
import { Button } from '@/components/ui/button';
import {
  Select,
  SelectContent,
  SelectItem,
  SelectTrigger,
  SelectValue,
} from '@/components/ui/select';
import {
  Dialog,
  DialogContent,
  DialogDescription,
  DialogFooter,
  DialogHeader,
  DialogTitle,
} from '@/components/ui/dialog';

const ContentPage = () => {
  const [selectedRows, setSelectedRows] = useState<number[]>([]);
  const [bulkAction, setBulkAction] = useState<string>('');
  const [showBulkDialog, setShowBulkDialog] = useState(false);
  const [selectedCluster, setSelectedCluster] = useState<number | null>(null);
  const [selectedTaxonomies, setSelectedTaxonomies] = useState<number[]>([]);
  
  const handleBulkActionClick = () => {
    if (selectedRows.length === 0) {
      toast.error('Please select at least one content item');
      return;
    }
    
    if (bulkAction === 'assign_cluster') {
      setShowBulkDialog(true);
      // Load clusters for dropdown
    } else if (bulkAction === 'assign_taxonomy') {
      setShowBulkDialog(true);
      // Load taxonomies for dropdown
    }
  };
  
  const handleBulkUpdate = async () => {
    try {
      const result = await bulkUpdateContent({
        content_ids: selectedRows,
        cluster_id: bulkAction === 'assign_cluster' ? selectedCluster : undefined,
        taxonomy_term_ids: bulkAction === 'assign_taxonomy' ? selectedTaxonomies : undefined,
      });
      
      toast.success(result.message);
      setShowBulkDialog(false);
      setSelectedRows([]);
      // Refresh table data
      
    } catch (error) {
      toast.error('Bulk update failed');
    }
  };
  
  return (
    <div>
      {/* Bulk Actions Toolbar */}
      {selectedRows.length > 0 && (
        <div className="mb-4 flex items-center gap-2 p-4 bg-blue-50 rounded-lg">
          <span className="text-sm font-medium">
            {selectedRows.length} selected
          </span>
          <Select value={bulkAction} onValueChange={setBulkAction}>
            <SelectTrigger className="w-[200px]">
              <SelectValue placeholder="Bulk Actions" />
            </SelectTrigger>
            <SelectContent>
              <SelectItem value="assign_cluster">Assign Cluster</SelectItem>
              <SelectItem value="assign_taxonomy">Assign Taxonomies</SelectItem>
            </SelectContent>
          </Select>
          <Button onClick={handleBulkActionClick}>Apply</Button>
        </div>
      )}
      
      {/* Bulk Assignment Dialog */}
      <Dialog open={showBulkDialog} onOpenChange={setShowBulkDialog}>
        <DialogContent>
          <DialogHeader>
            <DialogTitle>
              {bulkAction === 'assign_cluster' ? 'Assign Cluster' : 'Assign Taxonomies'}
            </DialogTitle>
            <DialogDescription>
              Update {selectedRows.length} selected content items
            </DialogDescription>
          </DialogHeader>
          
          {bulkAction === 'assign_cluster' && (
            <ClusterSelector
              value={selectedCluster}
              onChange={setSelectedCluster}
            />
          )}
          
          {bulkAction === 'assign_taxonomy' && (
            <TaxonomyMultiSelector
              value={selectedTaxonomies}
              onChange={setSelectedTaxonomies}
            />
          )}
          
          <DialogFooter>
            <Button variant="outline" onClick={() => setShowBulkDialog(false)}>
              Cancel
            </Button>
            <Button onClick={handleBulkUpdate}>
              Update {selectedRows.length} Items
            </Button>
          </DialogFooter>
        </DialogContent>
      </Dialog>
      
      {/* Existing table component */}
    </div>
  );
};

File: frontend/src/pages/Sites/Content.tsx

Apply same bulk operations UI pattern.

---

1.3 Sites Module — Remove Builder Buttons

File: frontend/src/pages/Sites/List.tsx

Remove buttons from site cards:

// REMOVE these imports and components:
// - BuilderButton
// - BlueprintsButton
// - PagesButton
// - SectorsButton (from card - move to Settings)

const SiteCard = ({ site }) => {
  return (
    <Card>
      <CardHeader>
        <CardTitle>{site.name}</CardTitle>
      </CardHeader>
      <CardContent>
        {/* KEEP these buttons */}
        <div className="flex gap-2">
          <Button asChild>
            <Link to={`/sites/${site.id}/dashboard`}>Dashboard</Link>
          </Button>
          <Button asChild>
            <Link to={`/sites/${site.id}/content`}>Content Manager</Link>
          </Button>
          <Button asChild>
            <Link to={`/sites/${site.id}/settings`}>Settings</Link>
          </Button>
        </div>
        
        {/* REMOVE these buttons:
        <Button>Builder</Button>
        <Button>Blueprints</Button>
        <Button>Pages</Button>
        <Button>Sectors</Button>
        */}
      </CardContent>
    </Card>
  );
};

// ADD active/inactive toggle at top of page
const SitesList = () => {
  const [showInactive, setShowInactive] = useState(false);
  
  return (
    <div>
      <div className="mb-6 flex justify-between items-center">
        <h1>Sites</h1>
        <div className="flex items-center gap-2">
          <Switch
            checked={showInactive}
            onCheckedChange={setShowInactive}
          />
          <span>Show Inactive Sites</span>
        </div>
      </div>
      
      {/* Site cards grid */}
    </div>
  );
};

File: frontend/src/pages/Sites/Settings.tsx

Add Sectors tab:

const SettingsPage = () => {
  const tabs = [
    { id: 'general', label: 'General' },
    { id: 'wordpress', label: 'WordPress Integration' },
    { id: 'sectors', label: 'Sectors' },  // ADD THIS
    { id: 'advanced', label: 'Advanced' },
  ];
  
  return (
    <Tabs defaultValue="general">
      <TabsList>
        {tabs.map(tab => (
          <TabsTrigger key={tab.id} value={tab.id}>
            {tab.label}
          </TabsTrigger>
        ))}
      </TabsList>
      
      {/* ... existing tabs ... */}
      
      <TabsContent value="sectors">
        <Card>
          <CardHeader>
            <CardTitle>Sectors Management</CardTitle>
            <CardDescription>
              Organize content by business sectors/categories
            </CardDescription>
          </CardHeader>
          <CardContent>
            <SectorsManager siteId={siteId} />
          </CardContent>
        </Card>
      </TabsContent>
    </Tabs>
  );
};

---

1.4 Content Manager — Unassigned Cluster Filter

File: frontend/src/config/pages/content.config.tsx

Add filter option:

export const contentFilters = {
  // ... existing filters ...
  cluster: {
    label: 'Cluster',
    options: [
      { value: 'null', label: 'Unassigned' },  // ADD THIS
      // ... dynamic cluster options loaded from API ...
    ],
  },
};

File: frontend/src/pages/Writer/Content.tsx

Highlight unassigned rows:

const getRowClassName = (row: Content) => {
  if (!row.cluster_id) {
    return 'bg-yellow-50 border-l-4 border-l-yellow-500';
  }
  return '';
};

// Apply to table row rendering
<TableRow className={getRowClassName(content)}>
  ...
</TableRow>

---

⚠️ PHASE 2: BACKEND CLEANUP (Day 1.5-2)

2.1 Remove Deprecated Filter Fields

File: backend/igny8_core/modules/writer/views.py

Before:

class ContentTaxonomyViewSet(SiteSectorModelViewSet):
    filterset_fields = ['taxonomy_type', 'sync_status', 'parent', 'external_id', 'external_taxonomy']

After:

class ContentTaxonomyViewSet(SiteSectorModelViewSet):
    # Stage 1: Removed sync_status and parent fields
    filterset_fields = ['taxonomy_type', 'external_id', 'external_taxonomy']

---

2.2 Add Publish Validation

File: backend/igny8_core/modules/writer/views.py

Update publish_content action:

@action(detail=True, methods=['post'])
def publish_content(self, request, pk=None):
    """Publish content to WordPress"""
    content = self.get_object()
    
    # Validation checks per spec
    if content.status != 'draft':
        return Response({
            'success': False,
            'error': f'Content must be in draft status (current: {content.status})'
        }, status=400)
    
    if not content.site.wordpress_endpoint:
        return Response({
            'success': False,
            'error': 'Site WordPress endpoint not configured'
        }, status=400)
    
    if not content.site.wordpress_auth_token:
        return Response({
            'success': False,
            'error': 'WordPress authentication not configured'
        }, status=400)
    
    if content.external_id:
        return Response({
            'success': False,
            'error': 'Content already published (external_id exists)'
        }, status=400)
    
    # Proceed with publish
    # ... existing publish logic ...

---

2.3 Clean Up Management Commands

File: backend/igny8_core/modules/writer/management/commands/audit_site_metadata.py

Remove cluster_role references:

# REMOVE these lines:
tasks_with_cluster_role = tasks.filter(cluster_role__isnull=False).count()
self.stdout.write(f'  With Cluster Role: {tasks_with_cluster_role}/{total_tasks} ...')

# REMOVE this section:
roles = tasks.values('cluster_role').annotate(count=Count('id')).order_by('-count')
for role in roles:
    self.stdout.write(f'  {role["cluster_role"] or "NULL"}: {role["count"]} tasks')

# REPLACE WITH:
# Show content_type distribution instead
types = tasks.values('content_type').annotate(count=Count('id')).order_by('-count')
for type_obj in types:
    self.stdout.write(f'  {type_obj["content_type"]}: {type_obj["count"]} tasks')

---

🎨 PHASE 3: FRONTEND POLISH (Day 2-2.5)

3.1 PostEditor — Remove SEO/Metadata Tabs

File: frontend/src/pages/Sites/PostEditor.tsx

Before (3 tabs):

const tabs = [
  { id: 'content', label: 'Content' },
  { id: 'seo', label: 'SEO' },  // REMOVE
  { id: 'metadata', label: 'Metadata' },  // REMOVE
];

After (2 tabs):

const tabs = [
  { id: 'content', label: 'Content' },
  { id: 'taxonomy', label: 'Taxonomy & Cluster' },
];

// REMOVE entire SEO tab content (lines ~450-550):
// - meta_title input
// - meta_description textarea
// - primary_keyword input
// - secondary_keywords input

// REMOVE entire Metadata tab content (lines ~550-650):
// - tags selector (use taxonomy_terms instead)
// - categories selector (use taxonomy_terms instead)

// KEEP Taxonomy & Cluster tab:
<TabsContent value="taxonomy">
  <Card>
    <CardHeader>
      <CardTitle>Taxonomy & Cluster Assignment</CardTitle>
    </CardHeader>
    <CardContent>
      {/* Cluster selector */}
      <div className="mb-4">
        <Label>Cluster</Label>
        <ClusterSelect
          value={content.cluster_id}
          onChange={(id) => setContent({ ...content, cluster_id: id })}
        />
      </div>
      
      {/* Taxonomy terms (read-only display or multi-select) */}
      <div>
        <Label>Taxonomy Terms</Label>
        <TaxonomyMultiSelect
          value={content.taxonomy_terms?.map(t => t.id) || []}
          onChange={(ids) => updateTaxonomyTerms(ids)}
        />
      </div>
    </CardContent>
  </Card>
</TabsContent>

---

3.2 ToggleTableRow — Remove Deprecated Fallbacks

File: frontend/src/components/common/ToggleTableRow.tsx

Remove these fallback patterns:

// REMOVE:
const primaryKeyword = row.primary_keyword || '';
const metaDescription = row.meta_description || row.description || '';
const tags = row.tags || [];
const categories = row.categories || [];

// REPLACE WITH new schema only:
const title = row.title;
const contentHtml = row.content_html;
const taxonomyTerms = row.taxonomy_terms || [];
const cluster = row.cluster_name || 'Unassigned';

---

3.3 Writer Tasks — Add Content Manager Link

File: frontend/src/pages/Writer/Tasks.tsx

Add action button:

const taskActions = [
  {
    label: 'Generate Content',
    onClick: (task) => handleGenerateContent(task.id),
    show: (task) => task.status === 'queued',
  },
  {
    label: 'View in Content Manager',  // ADD THIS
    onClick: (task) => {
      // Navigate to Content Manager filtered by this task's cluster
      navigate(`/writer/content?cluster_id=${task.cluster_id}`);
    },
    show: (task) => task.status === 'completed',
  },
];

---

3.4 Update Test Mocks

File: frontend/src/pages/Optimizer/__tests__/ContentSelector.test.tsx

Before:

const mockContent = [
  { id: 1, title: 'Test', source: 'igny8', sync_status: 'native', ... }
];

After:

const mockContent = [
  { 
    id: 1, 
    title: 'Test', 
    source: 'igny8',
    content_type: 'post',
    content_structure: 'article',
    cluster_id: 1,
    cluster_name: 'Test Cluster',
    taxonomy_terms: [],
    status: 'draft',
    // REMOVED: sync_status, entity_type, cluster_role
  }
];

Apply same pattern to all test files.

---

3.5 Verify Cluster Detail Tabs

File: frontend/src/pages/Planner/ClusterDetail.tsx

Ensure all 4 tabs exist:

const contentTypeTabs = [
  { id: 'post', label: 'Articles', icon: FileText },
  { id: 'page', label: 'Pages', icon: Layout },
  { id: 'product', label: 'Products', icon: Package },
  { id: 'category', label: 'Taxonomy Pages', icon: Tag },  // Verify this exists
];

---

🧪 PHASE 4: VERIFICATION & DOCS (Day 2.5-3)

4.1 End-to-End Testing

Test Scenario 1: Full Pipeline

1. Planner → Create keywords
2. Planner → Generate clusters
3. Planner → Generate ideas
4. Planner → Queue to Writer (bulk action)
5. Writer → Tasks → Verify tasks created with content_type/content_structure
6. Writer → Generate content for task
7. Writer → Content Manager → Verify content created with status=draft
8. Content Manager → Select 3 content items
9. Content Manager → Bulk assign cluster
10. Content Manager → Bulk assign taxonomies
11. Content Manager → Publish to WordPress
12. Verify external_id and external_url set
13. Try publishing again → Should get error

Test Scenario 2: WordPress Import

1. WordPress site with 10 posts
2. IGNY8 → Integration → Import from WordPress
3. Content Manager → Filter by source=wordpress
4. Content Manager → Filter by cluster=null
5. Content Manager → Bulk assign cluster to imported content
6. Verify cluster_id updated

Test Scenario 3: Cluster Detail

1. Navigate to Cluster Detail page
2. Verify 4 tabs: Articles, Pages, Products, Taxonomy
3. Click each tab
4. Verify content filtered by content_type
5. Click content item → Opens in Content Manager

Test Scenario 4: Sites Module

1. Sites → List page
2. Verify NO builder/blueprints/pages buttons on cards
3. Verify active/inactive toggle at top
4. Click Settings on a site
5. Verify Sectors tab exists
6. Verify sectors can be managed

---

4.2 Documentation Updates

File: STAGE_4_COMPLETE.md

Create comprehensive completion document:

# STAGE 4 IMPLEMENTATION — DDAY REFACTOR 100% COMPLETE

**Date:** [Completion Date]
**Status:** ✅ 100% COMPLETE (All Original Spec Requirements Met)

## Objective Achieved
- ✅ 20 gaps closed
- ✅ Batch operations implemented
- ✅ Sites module cleaned
- ✅ All deprecated fields removed
- ✅ 100% original DDAY spec compliance

## Files Modified
- Backend: 6 files
- Frontend: 10 files
- WordPress Plugin: 1 file
- Documentation: 3 files

## What Was Built
1. Bulk cluster assignment
2. Bulk taxonomy assignment
3. Sites UI cleanup (builder buttons removed)
4. Publish validation
5. PostEditor refactor
6. Deprecated field cleanup
7. Test updates

## Verification Results
- ✅ Full pipeline test passed
- ✅ WordPress import test passed
- ✅ Cluster detail test passed
- ✅ Sites module test passed

File: CHANGELOG.md

Add Stage 4 entry:

### [2025-11-26] IGNY8 Stage 4 — DDAY Refactor Completion

**Status:** ✅ 100% COMPLETE (All Original Specifications Implemented)

**Summary:**
Stage 4 closed all remaining gaps from the original DDAY refactor specifications. The platform now has complete batch operations, cleaned Sites UI, removed all deprecated field references, and achieved 100% spec compliance.

#### Added
- Bulk cluster assignment for content
- Bulk taxonomy assignment for content
- Content Manager selection UI with checkboxes
- Publish validation (draft status, site config checks)
- Sectors management tab in Site Settings
- Active/inactive toggle for Sites list
- "View in Content Manager" link from Writer tasks
- Unassigned cluster filter and highlighting

#### Changed
- Sites module: Removed builder, blueprints, pages buttons
- PostEditor: Removed SEO and Metadata tabs
- ToggleTableRow: Removed deprecated field fallbacks
- ContentTaxonomy filters: Removed sync_status and parent

#### Fixed
- Management command: Removed cluster_role references
- Frontend tests: Updated mocks to new schema
- All deprecated field references eliminated

#### Removed
- SEO tab from PostEditor
- Metadata tab from PostEditor
- Builder-related buttons from Sites cards
- All cluster_role, sync_status, entity_type references

File: original-specs of-refactor

Add completion notice at top:

✅ IMPLEMENTATION STATUS: 100% COMPLETE (Stage 4 - November 26, 2025)

All specifications in this document have been fully implemented across Stages 1-4.
See STAGE_4_COMPLETE.md for final implementation summary.

---
[Original specs follow below...]

---

📦 COMPLETE FILE CHECKLIST

Backend Files (6)

• backend/igny8_core/modules/writer/views.py

  • Remove sync_status and parent from ContentTaxonomyViewSet filters
  • Add bulk_update action to ContentViewSet
  • Add publish validation checks

• backend/igny8_core/modules/writer/serializers.py

  • Add BulkUpdateContentSerializer

• backend/igny8_core/modules/writer/management/commands/audit_site_metadata.py

  • Remove cluster_role references
  • Replace with content_type stats

• backend/igny8_core/business/publishing/services/adapters/wordpress_adapter.py

  • Verify cluster_id sent to WordPress plugin

Frontend Files (10)

• frontend/src/pages/Writer/Content.tsx

  • Add bulk operations toolbar
  • Add selection state management
  • Add bulk assignment dialogs

• frontend/src/pages/Sites/Content.tsx

  • Add same bulk operations UI

• frontend/src/config/pages/content.config.tsx

  • Add selection column
  • Add "Unassigned" cluster filter option

• frontend/src/services/api.ts

  • Add bulkUpdateContent function
  • Add interfaces

• frontend/src/pages/Sites/List.tsx

  • Remove builder/blueprints/pages buttons
  • Add active/inactive toggle

• frontend/src/pages/Sites/Settings.tsx

  • Add Sectors tab
  • Create SectorsManager component

• frontend/src/pages/Sites/PostEditor.tsx

  • Remove SEO tab
  • Remove Metadata tab
  • Keep only Content and Taxonomy tabs

• frontend/src/components/common/ToggleTableRow.tsx

  • Remove deprecated field fallbacks

• frontend/src/pages/Writer/Tasks.tsx

  • Add "View in Content Manager" action

• frontend/src/pages/Optimizer/__tests__/ContentSelector.test.tsx

  • Update test mocks to new schema

WordPress Plugin (1)

• sync/igny8-to-wp.php
  • Verify _igny8_cluster_id meta field saved

Documentation (4)

• STAGE_4_COMPLETE.md (create)
• CHANGELOG.md (update)
• original-specs of-refactor (add completion notice)
• REFACTOR_GAP_ANALYSIS.md (already created)

---

🎯 SUCCESS METRICS

Technical Compliance

• ✅ 0 deprecated field references in active code
• ✅ 0 TypeScript compilation errors
• ✅ All backend ViewSet filters use only Stage 1 schema
• ✅ All frontend components use only Stage 1 schema

Feature Completeness

• ✅ Batch cluster assignment works for 1-100 items
• ✅ Batch taxonomy assignment works for 1-100 items
• ✅ Sites module shows only Dashboard/Content/Settings buttons
• ✅ PostEditor has only 2 tabs (Content, Taxonomy & Cluster)
• ✅ Publish validation prevents invalid operations

User Experience

• ✅ Content Manager is single source of truth
• ✅ Unassigned imported content clearly visible
• ✅ Bulk operations intuitive and fast
• ✅ No confusing deprecated UI elements

Code Quality

• ✅ No console errors in browser
• ✅ All tests passing
• ✅ Build time < 15s
• ✅ No unused imports or dead code

---

🚀 DEPLOYMENT STEPS

Pre-Deployment

1. Run backend tests: python manage.py test
2. Run frontend build: npm run build
3. Check for TypeScript errors
4. Review all changed files

Deployment

1. Deploy backend to staging
2. Run migrations (none expected)
3. Deploy frontend to staging
4. Run E2E tests on staging
5. Deploy to production
6. Monitor for errors

Post-Deployment

1. Verify bulk operations work
2. Verify Sites UI clean
3. Verify publish validation
4. Update user documentation
5. Announce Stage 4 completion

---

💡 FUTURE ENHANCEMENTS (Post-Stage 4)

Short Term (Next 2-4 weeks)

• Auto-cluster assignment for imported content (ML-based)
• Scheduled bulk publishing
• Content preview before publish
• Advanced content search

Medium Term (Next 1-3 months)

• Full Optimizer module refactor
• Linker module alignment
• Content versioning
• A/B testing for content

Long Term (Next 3-6 months)

• AI-powered content suggestions
• Performance analytics dashboard
• Multi-site content sharing
• Advanced taxonomy auto-tagging

---

Stage 4 Completion Target: 100% DDAY Refactor Spec Compliance
Estimated Completion Date: [3 days from start]
Status: Ready for Implementation ✅