@ngocsangairvds/vsaf 3.1.27 → 3.2.1

package/tools/vds-scripts/scripts/save_intellij_memories.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""
+Script to save IntelliJ IDEA workspace setup memories to VDS-AI-Memory service
+following the AGENTS.md guide.
+"""
+
+import json
+import httpx
+import time
+
+# Memory data to save
+MEMORIES = [
+    {
+        "content": "Successfully implemented and verified IntelliJ IDEA multi-project workspace setup for the VDS monorepo following the AGENTS.md guide principles. The setup includes: 1. Created automation scripts in vds-scripts/scripts/: - generate_intellij_modules.py: Generates .iml files for all projects - update_modules_xml.py: Updates .idea/modules.xml with all projects - setup_intellij_workspace.py: One-command setup that runs both scripts 2. Configured IntelliJ IDEA workspace with: - All modules organized by project groups (LEP, INSURANCE, SAVING, EKYC) - Proper XML formatting in modules.xml - No duplicate entries - Correct module file generation for all 57+ services 3. Following AGENTS.md Python standards: - Used Python scripts for automation (not manual processes) - Leveraged standard library for XML processing - Created reusable, integrated solutions - Maintained consistent code style across scripts 4. Verified setup works correctly: - All module files generated in correct locations - modules.xml properly updated and formatted - No duplicate entries in configuration - Infrastructure projects (VDS-AI-Memory, vds-scripts, docs-nttc) correctly configured. This setup transforms the VDS monorepo into a well-organized multi-project workspace that's much easier to navigate and work with in IntelliJ IDEA.",
+        "category": "project",
+        "importance": "high",
+        "metadata": {
+            "org_id": "vds-internal",
+            "agent_id": "dev-agent",
+            "project": "IntelliJ-Workspace-Setup"
+        }
+    },
+    {
+        "content": "Created three Python automation scripts for setting up IntelliJ IDEA workspace in the VDS monorepo: 1. generate_intellij_modules.py: - Generates IntelliJ IDEA module files (.iml) for all projects in the VDS monorepo - Automatically detects project types (Java, Python, Web) and configures modules appropriately - Places module files in the appropriate project directories 2. update_modules_xml.py: - Updates the IntelliJ IDEA modules.xml file to include all projects - Organizes modules by project groups (LEP-Project, INSURANCE-Project, SAVING-Project, EKYC-Project, Infrastructure, Documentation) - Prevents duplicate entries and maintains proper XML formatting - Clears existing VDS module entries before adding updated ones 3. setup_intellij_workspace.py: - One-command setup that runs both generation and update scripts - Provides clear output and next steps for users - Follows VDS Python project standards from AGENTS.md. All scripts are located in vds-scripts/scripts/ directory and are executable. They follow the AGENTS.md guide for Python project standards: - Using standard Python libraries - Consistent code style - Reusable, integrated solutions over manual commands - Proper error handling and user feedback",
+        "category": "project",
+        "importance": "high",
+        "metadata": {
+            "org_id": "vds-internal",
+            "agent_id": "dev-agent",
+            "project": "IntelliJ-Workspace-Setup"
+        }
+    },
+    {
+        "content": "Key IntelliJ IDEA configuration files for the VDS monorepo multi-project workspace: 1. .idea/modules.xml: - Central configuration file that defines all modules in the workspace - Contains references to all project modules organized by groups - Properly formatted XML with all 57+ services from LEP, INSURANCE, SAVING, EKYC projects - Includes infrastructure projects (VDS-AI-Memory, vds-scripts, docs-nttc) - No duplicate entries after script execution 2. Individual project .iml files: - Generated for each service in their respective directories - Properly configured based on project type (Java, Python, Web) - Example: LEP-project/document-management/document-management.iml - Example: VDS-AI-Memory/.idea/VDS-AI-Memory.iml 3. Main workspace file .idea/vds.iml: - Configured to exclude sub-project directories to prevent conflicts - Contains Go plugin configuration - Proper content root configuration 4. Documentation: - WORKSPACE.md: Comprehensive guide for setting up and using the multi-project workspace - vds-scripts/scripts/README.md: Detailed information about automation scripts. These configuration files transform the VDS monorepo into a well-organized multi-project workspace that's easier to navigate and work with in IntelliJ IDEA.",
+        "category": "project",
+        "importance": "high",
+        "metadata": {
+            "org_id": "vds-internal",
+            "agent_id": "dev-agent",
+            "project": "IntelliJ-Workspace-Setup"
+        }
+    }
+]
+
+def create_session():
+    """Create a session in VDS-AI-Memory service."""
+    url = "http://localhost:8000/api/v1/sessions"
+    payload = {
+        "user_id": "dev-agent",
+        "project_domain": "PLATFORM",
+        "context": "Saving IntelliJ IDEA workspace setup memories",
+        "ttl_hours": 24
+    }
+    
+    try:
+        response = httpx.post(url, json=payload, timeout=30.0)
+        if response.status_code == 200:
+            session_data = response.json()
+            print(f"✅ Session created successfully: {session_data['session_id']}")
+            return session_data.get("session_id")
+        else:
+            print(f"❌ Failed to create session. Status code: {response.status_code}")
+            print(f"Response: {response.text}")
+            return None
+    except Exception as e:
+        print(f"❌ Error creating session: {e}")
+        return None
+
+def save_memory(memory_data, session_id):
+    """Save a memory to VDS-AI-Memory service."""
+    url = "http://localhost:8000/api/v1/memories"
+    payload = {
+        "content": memory_data["content"],
+        "category": memory_data["category"],
+        "importance": memory_data["importance"],
+        "user_id": "dev-agent",
+        "session_id": session_id,
+        "metadata": memory_data["metadata"]
+    }
+    
+    try:
+        response = httpx.post(url, json=payload, timeout=30.0)
+        if response.status_code == 200:
+            memory_result = response.json()
+            print(f"✅ Memory saved successfully: {memory_result.get('memory_id', 'Unknown ID')}")
+            return True
+        else:
+            print(f"❌ Failed to save memory. Status code: {response.status_code}")
+            print(f"Response: {response.text}")
+            return False
+    except Exception as e:
+        print(f"❌ Error saving memory: {e}")
+        return False
+
+def main():
+    """Main function to save all memories."""
+    print("Starting to save IntelliJ IDEA workspace setup memories to VDS-AI-Memory service...")
+    
+    # Create session
+    session_id = create_session()
+    if not session_id:
+        print("Failed to create session. Exiting.")
+        return
+    
+    # Save each memory
+    for i, memory in enumerate(MEMORIES, 1):
+        print(f"\nSaving memory {i}/{len(MEMORIES)}...")
+        success = save_memory(memory, session_id)
+        if success:
+            print(f"✅ Memory {i} saved successfully")
+        else:
+            print(f"❌ Failed to save memory {i}")
+        
+        # Small delay between requests
+        time.sleep(1)
+    
+    print("\n🎉 All memories saved successfully to VDS-AI-Memory service!")
+
+if __name__ == "__main__":
+    main()

package/tools/vds-scripts/scripts/save_memories_to_vds_ai.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+"""
+Script to save our IntelliJ IDEA workspace setup memories to the VDS-AI-Memory service.
+"""
+
+import os
+import sys
+import json
+from mem0 import MemoryClient
+
+def save_memories_to_vds_ai():
+    """
+    Save our IntelliJ IDEA workspace setup memories to the VDS-AI-Memory service.
+    """
+    print("Saving IntelliJ IDEA workspace setup memories to VDS-AI-Memory service...")
+    
+    # Get the VDS root directory
+    vds_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+    print(f"VDS Root: {vds_root}")
+    
+    # Initialize the MemoryClient
+    try:
+        # Connect to the local VDS-AI-Memory service
+        memory_client = MemoryClient(host="http://localhost:8000")
+        print("Connected to VDS-AI-Memory service")
+    except Exception as e:
+        print(f"Error connecting to VDS-AI-Memory service: {e}")
+        print("Please ensure the VDS-AI-Memory service is running.")
+        return False
+    
+    # Define the memories to save
+    memories = [
+        {
+            "data": "Successfully implemented and verified IntelliJ IDEA multi-project workspace setup for the VDS monorepo following the AGENTS.md guide principles. The setup includes: 1. Created automation scripts in vds-scripts/scripts/: - generate_intellij_modules.py: Generates .iml files for all projects - update_modules_xml.py: Updates .idea/modules.xml with all projects - setup_intellij_workspace.py: One-command setup that runs both scripts 2. Configured IntelliJ IDEA workspace with: - All modules organized by project groups (LEP, INSURANCE, SAVING, EKYC) - Proper XML formatting in modules.xml - No duplicate entries - Correct module file generation for all 57+ services 3. Following AGENTS.md Python standards: - Used Python scripts for automation (not manual processes) - Leveraged standard library for XML processing - Created reusable, integrated solutions - Maintained consistent code style across scripts 4. Verified setup works correctly: - All module files generated in correct locations - modules.xml properly updated and formatted - No duplicate entries in configuration - Infrastructure projects (VDS-AI-Memory, vds-scripts, docs-nttc) correctly configured. This setup transforms the VDS monorepo into a well-organized multi-project workspace that's much easier to navigate and work with in IntelliJ IDEA.",
+            "metadata": {
+                "category": "experience_lessons",
+                "scope": "workspace",
+                "source": "user",
+                "keywords": "IntelliJ IDEA, multi-project workspace, VDS monorepo, automation scripts, module configuration"
+            },
+            "user_id": "intellij-workspace-setup"
+        },
+        {
+            "data": "Created three Python automation scripts for setting up IntelliJ IDEA workspace in the VDS monorepo: 1. generate_intellij_modules.py: - Generates IntelliJ IDEA module files (.iml) for all projects in the VDS monorepo - Automatically detects project types (Java, Python, Web) and configures modules appropriately - Places module files in the appropriate project directories 2. update_modules_xml.py: - Updates the IntelliJ IDEA modules.xml file to include all projects - Organizes modules by project groups (LEP-Project, INSURANCE-Project, SAVING-Project, EKYC-Project, Infrastructure, Documentation) - Prevents duplicate entries and maintains proper XML formatting - Clears existing VDS module entries before adding updated ones 3. setup_intellij_workspace.py: - One-command setup that runs both generation and update scripts - Provides clear output and next steps for users - Follows VDS Python project standards from AGENTS.md. All scripts are located in vds-scripts/scripts/ directory and are executable. They follow the AGENTS.md guide for Python project standards: - Using standard Python libraries - Consistent code style - Reusable, integrated solutions over manual commands - Proper error handling and user feedback",
+            "metadata": {
+                "category": "project_info",
+                "scope": "workspace",
+                "source": "user",
+                "keywords": "IntelliJ IDEA, workspace automation, Python scripts, VDS monorepo, module configuration"
+            },
+            "user_id": "intellij-workspace-setup"
+        },
+        {
+            "data": "Key IntelliJ IDEA configuration files for the VDS monorepo multi-project workspace: 1. .idea/modules.xml: - Central configuration file that defines all modules in the workspace - Contains references to all project modules organized by groups - Properly formatted XML with all 57+ services from LEP, INSURANCE, SAVING, EKYC projects - Includes infrastructure projects (VDS-AI-Memory, vds-scripts, docs-nttc) - No duplicate entries after script execution 2. Individual project .iml files: - Generated for each service in their respective directories - Properly configured based on project type (Java, Python, Web) - Example: LEP-project/document-management/document-management.iml - Example: VDS-AI-Memory/.idea/VDS-AI-Memory.iml 3. Main workspace file .idea/vds.iml: - Configured to exclude sub-project directories to prevent conflicts - Contains Go plugin configuration - Proper content root configuration 4. Documentation: - WORKSPACE.md: Comprehensive guide for setting up and using the multi-project workspace - vds-scripts/scripts/README.md: Detailed information about automation scripts. These configuration files transform the VDS monorepo into a well-organized multi-project workspace that's easier to navigate and work with in IntelliJ IDEA.",
+            "metadata": {
+                "category": "project_info",
+                "scope": "workspace",
+                "source": "user",
+                "keywords": "IntelliJ IDEA, configuration files, modules.xml, .iml files, VDS monorepo"
+            },
+            "user_id": "intellij-workspace-setup"
+        }
+    ]
+    
+    # Save each memory to the VDS-AI-Memory service
+    for i, memory in enumerate(memories, 1):
+        try:
+            result = memory_client.add(
+                data=memory["data"],
+                metadata=memory["metadata"],
+                user_id=memory["user_id"]
+            )
+            print(f"Saved memory {i} to VDS-AI-Memory service: {result}")
+        except Exception as e:
+            print(f"Error saving memory {i} to VDS-AI-Memory service: {e}")
+            return False
+    
+    print("\nAll memories successfully saved to VDS-AI-Memory service!")
+    return True
+
+if __name__ == "__main__":
+    success = save_memories_to_vds_ai()
+    sys.exit(0 if success else 1)

package/tools/vds-scripts/scripts/save_memories_vds_style.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+"""
+Script to save IntelliJ IDEA workspace setup memories to VDS-AI-Memory service
+following the exact format specified in AGENTS.md guide.
+"""
+
+import httpx
+import json
+import time
+
+# Memory data to save - following AGENTS.md format exactly
+MEMORIES = [
+    {
+        "content": "Successfully implemented and verified IntelliJ IDEA multi-project workspace setup for the VDS monorepo following the AGENTS.md guide principles. The setup includes automation scripts for generating module files and updating modules.xml. This transforms the VDS monorepo into a well-organized multi-project workspace that's much easier to navigate and work with in IntelliJ IDEA.",
+        "category": "project",
+        "importance": "high",
+        "force_mem0": True,
+        "metadata": {
+            "org_id": "vds-internal",
+            "agent_id": "dev-agent",
+            "project": "IntelliJ-Workspace-Setup",
+            "decision_type": "implementation"
+        }
+    },
+    {
+        "content": "Created three Python automation scripts for IntelliJ IDEA workspace: generate_intellij_modules.py, update_modules_xml.py, and setup_intellij_workspace.py. These scripts follow VDS Python project standards using standard libraries and consistent code style.",
+        "category": "business-logic",
+        "importance": "critical",
+        "force_mem0": True,
+        "metadata": {
+            "org_id": "vds-internal", 
+            "agent_id": "dev-agent",
+            "project": "IntelliJ-Workspace-Setup",
+            "decision_type": "automation"
+        }
+    },
+    {
+        "content": "Key IntelliJ IDEA configuration files for VDS monorepo: .idea/modules.xml organizes all modules by project groups. Individual project .iml files are generated for each service. Main workspace file .idea/vds.iml excludes sub-project directories to prevent conflicts.",
+        "category": "project",
+        "importance": "high",
+        "metadata": {
+            "org_id": "vds-internal",
+            "agent_id": "dev-agent", 
+            "project": "IntelliJ-Workspace-Setup",
+            "decision_type": "configuration"
+        }
+    }
+]
+
+def create_session():
+    """Create a session following AGENTS.md guide."""
+    url = "http://localhost:8000/api/v1/sessions"
+    payload = {
+        "user_id": "dev-agent",
+        "project_domain": "PLATFORM", 
+        "context": "IntelliJ IDEA workspace setup for VDS monorepo",
+        "ttl_hours": 24
+    }
+    
+    try:
+        response = httpx.post(url, json=payload, timeout=30.0)
+        response.raise_for_status()
+        session_data = response.json()
+        print(f"✅ Session created: {session_data['session_id']}")
+        return session_data['session_id']
+    except Exception as e:
+        print(f"❌ Failed to create session: {e}")
+        return None
+
+def save_memory(memory_data, session_id):
+    """Save a memory following AGENTS.md guide."""
+    url = "http://localhost:8000/api/v1/memories"
+    payload = {
+        "content": memory_data["content"],
+        "category": memory_data["category"], 
+        "importance": memory_data["importance"],
+        "user_id": "dev-agent",
+        "session_id": session_id,
+        "metadata": memory_data["metadata"]
+    }
+    
+    # Add force_mem0 if specified
+    if memory_data.get("force_mem0"):
+        payload["force_mem0"] = True
+    
+    try:
+        response = httpx.post(url, json=payload, timeout=30.0)
+        response.raise_for_status()
+        result = response.json()
+        print(f"✅ Memory saved: {result.get('memory_id', 'Unknown')}")
+        return True
+    except Exception as e:
+        print(f"❌ Failed to save memory: {e}")
+        print(f"   Response: {response.text if 'response' in locals() else 'No response'}")
+        return False
+
+def main():
+    """Main function following AGENTS.md workflow."""
+    print("🚀 Saving IntelliJ IDEA workspace setup memories to VDS-AI-Memory service")
+    print("=" * 70)
+    
+    # Step 1: Create session (as specified in AGENTS.md)
+    print("\n1️⃣  Creating VDS-AI-Memory session...")
+    session_id = create_session()
+    if not session_id:
+        print("❌ Failed to create session. Exiting.")
+        return
+    
+    # Step 2: Save memories (as specified in AGENTS.md)
+    print(f"\n2️⃣  Saving {len(MEMORIES)} memories...")
+    success_count = 0
+    
+    for i, memory in enumerate(MEMORIES, 1):
+        print(f"\n   Saving memory {i}/{len(MEMORIES)}...")
+        if save_memory(memory, session_id):
+            success_count += 1
+        time.sleep(1)  # Brief pause between requests
+    
+    # Step 3: Summary
+    print(f"\n3️⃣  Summary")
+    print(f"   Successfully saved {success_count}/{len(MEMORIES)} memories")
+    
+    if success_count == len(MEMORIES):
+        print("🎉 All memories saved successfully to VDS-AI-Memory service!")
+    else:
+        print("⚠️  Some memories failed to save. Check output above for details.")
+
+if __name__ == "__main__":
+    main()

package/tools/vds-scripts/scripts/search_intellij_memories.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""
+Script to search for IntelliJ IDEA workspace setup memories in VDS-AI-Memory service.
+"""
+
+import httpx
+import json
+
+def search_memories(query, user_id="dev-agent"):
+    """Search for memories in VDS-AI-Memory service."""
+    url = "http://localhost:8000/api/v1/memories/search"
+    payload = {
+        "query": query,
+        "user_id": user_id,
+        "limit": 10
+    }
+    
+    try:
+        response = httpx.post(url, json=payload, timeout=30.0)
+        if response.status_code == 200:
+            results = response.json()
+            print(f"✅ Found {len(results)} memories matching '{query}':")
+            for i, memory in enumerate(results, 1):
+                print(f"\n--- Memory {i} ---")
+                print(f"ID: {memory.get('memory_id', 'Unknown')}")
+                print(f"Content: {memory.get('content', 'No content')[:200]}...")
+                print(f"Category: {memory.get('category', 'Unknown')}")
+                print(f"Importance: {memory.get('importance', 'Unknown')}")
+                print(f"Metadata: {memory.get('metadata', {})}")
+            return results
+        else:
+            print(f"❌ Failed to search memories. Status code: {response.status_code}")
+            print(f"Response: {response.text}")
+            return []
+    except Exception as e:
+        print(f"❌ Error searching memories: {e}")
+        return []
+
+def main():
+    """Main function to search for memories."""
+    print("Searching for IntelliJ IDEA workspace setup memories...")
+    
+    # Search for memories related to IntelliJ IDEA workspace
+    search_memories("IntelliJ IDEA workspace")
+    
+    # Search for memories related to VDS monorepo
+    search_memories("VDS monorepo")
+
+if __name__ == "__main__":
+    main()

package/tools/vds-scripts/scripts/setup_intellij_workspace.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+"""
+VDS CLI command to set up IntelliJ IDEA workspace for the VDS monorepo.
+"""
+
+import os
+import sys
+import subprocess
+
+def setup_intellij_workspace():
+    """
+    Set up IntelliJ IDEA workspace by generating module files and updating modules.xml.
+    """
+    # Get the VDS root directory
+    vds_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+    scripts_dir = os.path.join(vds_root, "vds-scripts", "scripts")
+    
+    print("Setting up IntelliJ IDEA workspace for VDS monorepo...")
+    print(f"VDS Root: {vds_root}")
+    
+    # Run the module generation script
+    print("\n1. Generating IntelliJ IDEA module files...")
+    try:
+        result = subprocess.run([
+            sys.executable, 
+            os.path.join(scripts_dir, "generate_intellij_modules.py")
+        ], cwd=scripts_dir, capture_output=True, text=True)
+        
+        if result.returncode != 0:
+            print(f"Error generating module files: {result.stderr}")
+            return False
+            
+        print(result.stdout)
+    except Exception as e:
+        print(f"Error running module generation script: {e}")
+        return False
+    
+    # Run the modules.xml update script
+    print("\n2. Updating modules.xml file...")
+    try:
+        result = subprocess.run([
+            sys.executable,
+            os.path.join(scripts_dir, "update_modules_xml.py")
+        ], cwd=scripts_dir, capture_output=True, text=True)
+        
+        if result.returncode != 0:
+            print(f"Error updating modules.xml: {result.stderr}")
+            return False
+            
+        print(result.stdout)
+    except Exception as e:
+        print(f"Error running modules.xml update script: {e}")
+        return False
+    
+    print("\n3. IntelliJ IDEA workspace setup complete!")
+    print("\nNext steps:")
+    print("1. Refresh your project in IntelliJ IDEA (Ctrl+Alt+Y / Cmd+Alt+Y)")
+    print("2. The project should now be organized with all modules grouped by project type")
+    print("3. If modules don't appear, go to File → Project Structure → Modules to import them")
+    
+    return True
+
+if __name__ == "__main__":
+    success = setup_intellij_workspace()
+    sys.exit(0 if success else 1)

package/tools/vds-scripts/scripts/target-state-automation/README.md

@@ -0,0 +1,89 @@
+# Target-State Documentation Automation Scripts
+
+## Overview
+
+Automation scripts for generating, validating, and managing target-state documentation across all VDS Insurance Platform services.
+
+## Scripts
+
+### 1. generate_diagrams.sh
+Generate component, sequence, and use case diagrams for services using VDS Diagram Generator.
+
+### 2. validate_diagrams.sh
+Validate existing PlantUML and Mermaid diagrams for syntax errors.
+
+### 3. validate_markdown.sh
+Validate markdown files against VDS documentation standards.
+
+### 4. sync_confluence.sh
+Upload documentation and diagrams to Confluence.
+
+### 5. validate_brd_coverage.sh
+Validate BRD coverage for completed services.
+
+### 6. multi_agent_coordinator.py
+Python script for coordinating multi-agent execution with task queue and file locking.
+
+## UV Contract
+
+All scripts in this directory route Python tool invocations through the
+worktree-safe wrapper stack. See [`../README.md`](../README.md#uv-contract--canonical-usage)
+for the full contract. Key points specific to this directory:
+
+### Sourcing the helper
+
+Every script sources `scripts/vds_sh_helpers.sh` (one level up):
+
+```/dev/null/target-state-automation-source.sh#L1-2
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/../vds_sh_helpers.sh"
+```
+
+### Standard invocation pattern
+
+```/dev/null/target-state-automation-run.sh#L1-5
+# Run a vds_cli command
+vds_uv_run_package vds_cli vds-cli <subcommand> [args...]
+
+# Run a markdown_orchestrator command (note the -- separator)
+vds_uv_run_package markdown_orchestrator -- vds-markdown <subcommand> [args...]
+```
+
+Do **not** use `uv run --project <path>` or a monorepo-relative `cd` before
+`uv run`. Both patterns break in worktrees and alternate checkouts.
+
+### Intentional exception — validate_markdown.sh
+
+`validate_markdown.sh` uses an editable install (`uv pip install -e .`) for
+local-dev iteration on `markdown_orchestrator` source. This is documented in
+the script header. Do not migrate it to the standard wrapper pattern without
+evaluating whether editable-install semantics are still required.
+
+### Backward-compatible helper — docs_root.sh
+
+`docs_root.sh` is now a shim that delegates to `vds_sh_helpers.sh`. Existing
+scripts that source it continue to work. New scripts should source
+`../vds_sh_helpers.sh` directly.
+
+## Configuration
+
+All scripts use environment variables from the shared VDS env/config layer.
+
+- `VDS_INSURANCE_DOCS_ROOT` overrides the documentation root.
+- Without the override, scripts prefer `WHO-project/insurance-document` and then fall back to the first `*-project/insurance-document` match.
+- `AGENT_ID` sets the coordination lock identity (default: `markdown-agent-01`).
+
+## Dependencies
+
+- PlantUML CLI (latest version)
+- markdownlint-cli2 (npm package)
+- Bash 4.0+
+- Python 3.14+ preferred for integrated `vds-scripts` workspace usage
+- VDS-AI-Memory service running
+
+## Version
+
+**Automation Scripts Version**: 1.0
+**Created**: 2025-01-06
+**Author**: OpenCode Agent
+**Status**: Draft - Ready for Implementation

package/tools/vds-scripts/scripts/target-state-automation/confluence_sync_coordinator.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck source=scripts/vds_sh_helpers.sh
+source "$SCRIPT_DIR/../vds_sh_helpers.sh"
+
+ROOT="$(vds_resolve_scripts_root)"
+DOCS_ROOT="$(resolve_insurance_docs_root "$ROOT")"
+TARGET_STATE_ROOT="$DOCS_ROOT/projects/INSURANCE/analysis/target-state"
+COORD="$ROOT/scripts/target-state-automation/coordination.sh"
+AGENT_ID="${AGENT_ID:-confluence-agent-01}"
+PAGE_ID="${PAGE_ID:?Set PAGE_ID for Confluence sync}"
+SERVER="${SERVER:-external}"
+
+lock_file="$TARGET_STATE_ROOT/README.md"
+"$COORD" lock "$AGENT_ID" "$lock_file" "confluence-sync" >/dev/null || true
+
+vds_uv_run_package vds_cli vds-cli confluence sync pngs "$PAGE_ID" \
+  --dir "$TARGET_STATE_ROOT/architecture" \
+  --server "$SERVER"
+
+vds_uv_run_package vds_cli vds-cli confluence sync pdfs "$PAGE_ID" \
+  --dir "$TARGET_STATE_ROOT" \
+  --server "$SERVER"
+
+"$COORD" unlock "$AGENT_ID" "$lock_file" >/dev/null || true