메뉴
Advanced File I/O and shared state management for Claude Code multi-agent swarm operations with atomic operations, conflict resolution, and concurrent access control
기본적으로 소스를 먼저 확인하는 Prompt가 선택됩니다. 직접 명령으로 전환하거나 로컬 사본을 다운로드할 수도 있습니다.
설치 여부를 결정하기 전에 SKILL.md와 SkillsMP에 표시된 보조 파일을 읽어 보세요.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
직접 명령은 검토 Prompt를 거치지 않습니다. 실행하기 전에 소스를 확인하세요.
npx skills add https://github.com/aegntic/cldcde --skill fileio-swarm-advanced명령은 한 줄로 유지됩니다. 복사하기 전에 가로로 스크롤해 전체 내용을 확인하세요.
로컬 사본을 원하시나요? SkillsMP에서 현재 제공할 수 있는 파일을 다운로드하세요.
SKILL.md 표시 중
SOC 직업 분류 기준
| name | fileio-swarm-advanced |
| description | Advanced File I/O and shared state management for Claude Code multi-agent swarm operations with atomic operations, conflict resolution, and concurrent access control |
A comprehensive skill for managing shared state and data persistence in Claude Code multi-agent swarm operations. This skill provides atomic file operations, conflict resolution, concurrent access control, and progress tracking capabilities essential for coordinating multiple agents working on shared resources.
// Initialize swarm file manager
swarmFileManager = ({
: ,
: ,
: ,
:
});
swarmFileManager.(, {
: ,
: [, ],
:
});
updated = swarmFileManager.(,
({
...state,
: .(state. + , ),
: ().()
})
);
tracker = swarmFileManager.(, {
: ,
:
});
tracker.();
npm install fs-extra lockfile crypto// Agent 1: Initialize shared state
await swarmFileManager.createSharedState('task-queue', {
tasks: [],
completed: 0,
failed: 0,
status: 'initializing'
});
// Agent 2: Add tasks to queue
await swarmFileManager.updateSharedState('task-queue', (state) => ({
...state,
tasks: [
...state.tasks,
{ id: 'task-001', agent: 'agent-002', priority: 'high' }
]
}));
// Agent 3: Process and update status
const result = await swarmFileManager.updateSharedState('task-queue', (state) => {
const task = state.tasks.find(t => t.id === 'task-001');
if (task && task.status !== 'completed') {
return {
...state,
tasks: state.tasks.map(t =>
t.id === 'task-001'
? { ...t, status: 'completed', completedAt: Date.now() }
: t
),
completed: state.completed + 1
};
}
return state;
});
// Initialize progress tracker
const tracker = swarmFileManager.createProgressTracker('batch-processing', {
totalItems: 5000,
batchSize: 100,
agents: ['agent-001', 'agent-002', 'agent-003']
});
// Agent reports progress
await tracker.reportProgress({
agentId: 'agent-001',
completed: 1200,
errors: 2,
currentBatch: 13
});
// Get overall progress
const progress = await tracker.getProgress();
// Returns: { total: 5000, completed: 2400, percentage: 48, activeAgents: 3 }
// Configure conflict resolution strategy
const conflictResolver = new ConflictResolver({
strategy: 'merge-priority', // 'merge-priority', 'timestamp', 'manual'
priorityOrder: ['agent-001', 'agent-002', 'agent-003']
});
// Resolve conflicts automatically
const resolved = await conflictResolver.resolve('shared-config.json', {
agentAChanges: { timeout: 5000 },
agentBChanges: { retries: 3, timeout: 10000 }
});
// Result: { timeout: 10000, retries: 3 }
Main class for managing file operations in swarm environments.
new SwarmFileManager(options: SwarmFileManagerOptions)
createSharedState(name: string, data: any, options?: StateOptions)Creates a new shared state file with initial data.
getSharedState(name: string): Promise<any>Retrieves current shared state data.
updateSharedState(name: string, updater: Function, options?: UpdateOptions)Atomically updates shared state using provided updater function.
deleteSharedState(name: string): Promise<boolean>Safely removes shared state file.
lockFile(filePath: string, options?: LockOptions): Promise<LockHandle>Acquires exclusive lock on file for operations.
createProgressTracker(name: string, config: ProgressConfig): ProgressTrackerCreates progress tracker for monitoring long-running operations.
Handles progress tracking across multiple agents.
reportProgress(progress: ProgressReport): Promise<void>Reports progress from an agent.
getProgress(): Promise<ProgressSummary>Gets aggregated progress from all agents.
markComplete(agentId: string): Promise<void>Marks agent's work as complete.
reset(): Promise<void>Resets progress tracking.
Manages conflict resolution for concurrent file modifications.
resolve(filePath: string, conflicts: ConflictData[]): Promise<ResolvedData>Resolves conflicts using configured strategy.
detectConflicts(filePath: string): Promise<ConflictInfo[]>Detects potential conflicts in shared files.
interface SwarmFileManagerOptions {
workspace: string; // Root directory for swarm operations
agentId: string; // Unique identifier for this agent
lockTimeout?: number; // Lock timeout in milliseconds (default: 30000)
maxRetries?: number; // Max retry attempts (default: 3)
retryDelay?: number; // Delay between retries (default: 1000)
backupEnabled?: boolean; // Enable automatic backups (default: true)
logLevel?: 'debug' | 'info' | 'warn' | 'error'; // Log level
}
interface StateOptions {
format?: 'json' | 'yaml' | 'toml'; // File format
schema?: object; // JSON schema for validation
encryption?: boolean; // Enable encryption
ttl?: number; // Time to live in milliseconds
metadata?: object; // Additional metadata
}
interface ProgressConfig {
totalItems: number; // Total items to process
batchSize?: number; // Batch size for processing
agents: string[]; // List of participating agents
updateInterval?: number; // Progress update interval
checkpoints?: boolean; // Enable checkpointing
}
Deadlocks: Occur when agents wait indefinitely for locks
Race Conditions: Multiple agents modifying state simultaneously
File Corruption: Data integrity issues during concurrent access
Performance Bottlenecks: Slow file operations with many agents
Enable debug logging to trace file operations:
const fileManager = new SwarmFileManager({
workspace: '/workspace',
agentId: 'debug-agent',
logLevel: 'debug'
});
Monitor system resources and lock status:
# Check active locks
ls -la /workspace/.locks/
# Monitor file access
tail -f /workspace/.logs/file-operations.log
// Integrate with GitHub Actions
const githubIntegration = new GitHubFileIntegration(fileManager);
await githubIntegration.syncWithRepository({
repo: 'organization/project',
branch: 'main',
paths: ['shared-state/', 'progress/']
});
// Combine with AgentDB for hybrid storage
const hybridStorage = new HybridStorage({
fileManager: fileManager,
agentdb: agentdbClient,
syncStrategy: 'file-primary'
});
// Coordinate with swarm orchestration system
const swarmCoordinator = new SwarmCoordinator({
fileManager: fileManager,
communicationLayer: messageQueue,
consensusProtocol: 'raft'
});
This skill is designed to be extensible. To add new features:
This skill is part of the Claude Code ecosystem and follows the project's licensing terms.
Generated with Claude Code Advanced Template System
Run a 5-adviser council to stress-test any decision. Five distinct lenses (Contrarian, First-Principles, Expansionist, Outsider, Executor) answer independently, then anonymously peer-review each other, and a Chairman synthesizes a single clear recommendation. Kills sycophancy and groupthink on high-stakes calls.
Diligence-grade product and technical analysis for the ae.ltd proof-agent concept, including comparison against Cursor and Omnara, MVP and production architecture, red-team review, and build-vs-buy evaluation. Use when Codex needs to create or critique PRDs, tech specs, competitive diligence, leadership memos, or multi-agent evaluation packs for agent-runtime, demo-agent, or proof-agent products.
Use when creating or upgrading CLAUDE.md instructions and selecting the right template baseline for repo size, architecture, and team constraints. AE.LTD template decision workflow.