К основному содержанию
скилл CX Codex

schedule-cost-link — скилл для Claude Code

Скилл schedule-cost-link связывает работы из графика стройки с позициями сметы, строит денежные потоки и считает освоение по методу EV.

MIT 117 установок ★ 434 обновлён 2026-10-19

Установить в Claude Code · Через Skills CLI (Vercel) Все способы и платформы ↓
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill schedule-cost-link -a claude-code
Открыть на GitHub

Что делает schedule-cost-link

Скилл соединяет таблицу работ с бюджетными статьями и распределяет затраты по календарю проекта. Внутри — Python-класс ScheduleCostLinker, который умеет четыре способа распределения затрат: равномерно, с упором на начало, на конец или по колоколу. Он привязывает к каждой работе cost_code, выдаёт cost-loaded schedule, строит дневные кривые потока денег и рассчитывает набор метрик EV: BCWS, BCWP, SPI, CPI, EAC.

Требует python3 в PATH; процент выполнения работ и фактические затраты задаёшь вручную через методы класса. Скилл принимает три даты и длительность, а выход — pandas DataFrame с графиком и стоимостью по строкам.

Какие задачи решает

  • привязать работы графика к кодам сметы
  • построить cost-loaded schedule со статьями бюджета
  • сгенерировать кривую кэш-флоу по дням проекта
  • посчитать метрики освоения: SPI, CPI, EAC
  • распределить затраты равномерно, с упором в начало или конец, или по колоколу

Примеры запросов агенту

  • Создай cost-loaded schedule для работ из файла activities.csv, привяжи их к смете budget.xlsx
  • Построй кривую кэш-флоу для проекта с бюджетом 2 млн, работы грузи равномерно
  • Посчитай EV-метрики на сегодня: у меня есть процент выполнения и фактические затраты по работам

Как установить schedule-cost-link

1Через Skills CLI (Vercel)

npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill schedule-cost-link -a claude-code

2Вручную: положить файлы

~/.claude/skills/schedule-cost-link/SKILL.md

Папка скилла целиком; для одного проекта — .claude/skills/schedule-cost-link/

По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов

Вопросы о schedule-cost-link

Как установить schedule-cost-link в Claude Code?

Запусти npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill schedule-cost-link -a claude-code, скилл ляжет в ~/.claude/skills/schedule-cost-link/SKILL.md.

Что делает schedule-cost-link?

Связывает работы графика с позициями сметы, распределяет затраты по дням четырьмя способами (равномерно, спереди, сзади или колоколом), строит cost-loaded schedule и cash flow, считает метрики EV.

Какие данные нужны для расчёта EV-метрик?

Бюджет каждой работы, её даты начала и конца, процент выполнения и фактические затраты. Всё это передаёшь в методы класса ScheduleCostLinker.

Исходный текст

SKILL.md · MIT
---
name: "schedule-cost-link"
description: "Link schedule activities to cost items. Create cost-loaded schedules, generate cash flow curves, and track earned value."
homepage: "https://datadrivenconstruction.io"
metadata: {"openclaw": {"emoji": "📅", "os": ["darwin", "linux", "win32"], "homepage": "https://datadrivenconstruction.io", "requires": {"bins": ["python3"]}}}
---
# Schedule-Cost Linker

## Business Case

### Problem Statement
Integrating schedule and cost requires:
- Linking activities to budget items
- Creating cost-loaded schedules
- Generating cash flow forecasts
- Tracking earned value metrics

### Solution
Systematic linkage between schedule activities and cost data to enable integrated project control.

## Technical Implementation

```python
import pandas as pd
import numpy as np
from typing import Dict, Any, List, Optional, Tuple
from dataclasses import dataclass, field
from datetime import date, timedelta
from enum import Enum
from collections import defaultdict


class LoadingMethod(Enum):
    UNIFORM = "uniform"          # Even distribution
    FRONT_LOADED = "front_loaded"
    BACK_LOADED = "back_loaded"
    BELL_CURVE = "bell_curve"


@dataclass
class ScheduleActivity:
    activity_id: str
    name: str
    start_date: date
    finish_date: date
    duration: int
    percent_complete: float = 0


@dataclass
class CostItem:
    cost_code: str
    description: str
    budgeted_cost: float
    labor_cost: float
    material_cost: float
    equipment_cost: float


@dataclass
class ActivityCostLink:
    activity_id: str
    cost_code: str
    budgeted_cost: float
    loading_method: LoadingMethod


@dataclass
class EarnedValueMetrics:
    data_date: date
    bcws: float  # Budgeted Cost of Work Scheduled (PV)
    bcwp: float  # Budgeted Cost of Work Performed (EV)
    acwp: float  # Actual Cost of Work Performed (AC)
    sv: float    # Schedule Variance
    cv: float    # Cost Variance
    spi: float   # Schedule Performance Index
    cpi: float   # Cost Performance Index
    eac: float   # Estimate at Completion
    etc: float   # Estimate to Complete
    vac: float   # Variance at Completion


class ScheduleCostLinker:
    """Link schedule activities to cost items."""

    def __init__(self, project_name: str, budget_at_completion: float):
        self.project_name = project_name
        self.bac = budget_at_completion
        self.activities: Dict[str, ScheduleActivity] = {}
        self.cost_items: Dict[str, CostItem] = {}
        self.links: List[ActivityCostLink] = []
        self.actual_costs: Dict[str, float] = {}  # activity_id -> actual cost

    def add_activity(self,
                     activity_id: str,
                     name: str,
                     start_date: date,
                     finish_date: date,
                     percent_complete: float = 0):
        """Add schedule activity."""

        duration = (finish_date - start_date).days + 1

        self.activities[activity_id] = ScheduleActivity(
            activity_id=activity_id,
            name=name,
            start_date=start_date,
            finish_date=finish_date,
            duration=duration,
            percent_complete=percent_complete
        )

    def add_cost_item(self,
                      cost_code: str,
                      description: str,
                      budgeted_cost: float,
                      labor_pct: float = 0.4,
                      material_pct: float = 0.5,
                      equipment_pct: float = 0.1):
        """Add cost item."""

        self.cost_items[cost_code] = CostItem(
            cost_code=cost_code,
            description=description,
            budgeted_cost=budgeted_cost,
            labor_cost=budgeted_cost * labor_pct,
            material_cost=budgeted_cost * material_pct,
            equipment_cost=budgeted_cost * equipment_pct
        )

    def link_activity_cost(self,
                           activity_id: str,
                           cost_code: str,
                           loading_method: LoadingMethod = LoadingMethod.UNIFORM):
        """Link activity to cost item."""

        if activity_id not in self.activities:
            return

        cost_item = self.cost_items.get(cost_code)
        budgeted = cost_item.budgeted_cost if cost_item else 0

        self.links.append(ActivityCostLink(
            activity_id=activity_id,
            cost_code=cost_code,
            budgeted_cost=budgeted,
            loading_method=loading_method
        ))

    def record_actual_cost(self, activity_id: str, actual_cost: float):
        """Record actual cost for activity."""
        self.actual_costs[activity_id] = actual_cost

    def _distribute_cost(self,
                          cost: float,
                          start_date: date,
                          duration: int,
                          method: LoadingMethod) -> Dict[date, float]:
        """Distribute cost over activity duration."""

        daily_costs = {}

        if duration <= 0:
            return {start_date: cost}

        if method == LoadingMethod.UNIFORM:
            daily = cost / duration
            for i in range(duration):
                daily_costs[start_date + timedelta(days=i)] = daily

        elif method == LoadingMethod.FRONT_LOADED:
            total_weight = sum(range(duration, 0, -1))
            for i in range(duration):
                weight = (duration - i) / total_weight
                daily_costs[start_date + timedelta(days=i)] = cost * weight

        elif method == LoadingMethod.BACK_LOADED:
            total_weight = sum(range(1, duration + 1))
            for i in range(duration):
                weight = (i + 1) / total_weight
                daily_costs[start_date + timedelta(days=i)] = cost * weight

        elif method == LoadingMethod.BELL_CURVE:
            # Simplified bell curve
            mid = duration / 2
            for i in range(duration):
                distance = abs(i - mid)
                weight = 1 - (distance / mid) * 0.5
                daily_costs[start_date + timedelta(days=i)] = cost * weight / duration

        return daily_costs

    def generate_cost_loaded_schedule(self) -> pd.DataFrame:
        """Generate cost-loaded schedule."""

        data = []

        for link in self.links:
            activity = self.activities.get(link.activity_id)
            cost_item = self.cost_items.get(link.cost_code)

            if activity and cost_item:
                data.append({
                    'Activity ID': activity.activity_id,
                    'Activity Name': activity.name,
                    'Cost Code': link.cost_code,
                    'Description': cost_item.description,
                    'Start': activity.start_date,
                    'Finish': activity.finish_date,
                    'Duration': activity.duration,
                    'Budget': link.budgeted_cost,
                    '% Complete': activity.percent_complete,
                    'Earned Value': link.budgeted_cost * activity.percent_complete / 100,
                    'Loading': link.loading_method.value
                })

        return pd.DataFrame(data)

    def generate_cash_flow(self,
                           project_start: date = None,
                           project_end: date = None) -> pd.DataFrame:
        """Generate cash flow curve."""

        if not self.links:
            return pd.DataFrame()

        # Get date range
        if project_start is None:
            project_start = min(self.activities[l.activity_id].start_date for l in self.links)
        if project_end is None:
            project_end = max(self.activities[l.activity_id].finish_date for l in self.links)

        # Aggregate daily costs
        daily_totals = defaultdict(float)

        for link in self.links:
            activity = self.activities.get(link.activity_id)
            if not activity:
                continue

            daily_costs = self._distribute_cost(
                link.budgeted_cost,
                activity.start_date,
                activity.duration,
                link.loading_method
            )

            for day, cost in daily_costs.items():
                daily_totals[day] += cost

        # Build cash flow data
        data = []
        cumulative = 0
        current = project_start

        while current <= project_end:
            daily = daily_totals.get(current, 0)
            cumulative += daily

            data.append({
                'Date': current,
                'Daily': round(daily, 2),
                'Cumulative': round(cumulative, 2),
                'Cumulative %': round(cumulative / self.bac * 100, 1) if self.bac > 0 else 0
            })

            current += timedelta(days=1)

        return pd.DataFrame(data)

    def calculate_earned_value(self, data_date: date) -> EarnedValueMetrics:
        """Calculate earned value metrics at data date."""

        # BCWS - Planned Value through data date
        bcws = 0
        for link in self.links:
            activity = self.activities.get(link.activity_id)
            if not activity:
                continue

            daily_costs = self._distribute_cost(
                link.budgeted_cost,
                activity.start_date,
                activity.duration,
                link.loading_method
            )

            for day, cost in daily_costs.items():
                if day <= data_date:
                    bcws += cost

        # BCWP - Earned Value (budget * % complete)
        bcwp = 0
        for link in self.links:
            activity = self.activities.get(link.activity_id)
            if activity:
                bcwp += link.budgeted_cost * activity.percent_complete / 100

        # ACWP - Actual Cost
        acwp = sum(self.actual_costs.values())

        # Variances
        sv = bcwp - bcws
        cv = bcwp - acwp

        # Indices
        spi = bcwp / bcws if bcws > 0 else 0
        cpi = bcwp / acwp if acwp > 0 else 0

        # Forecasts
        eac = self.bac / cpi if cpi > 0 else self.bac
        etc = eac - acwp
        vac = self.bac - eac

        return EarnedValueMetrics(
            data_date=data_date,
            bcws=round(bcws, 2),
            bcwp=round(bcwp, 2),
            acwp=round(acwp, 2),
            sv=round(sv, 2),
            cv=round(cv, 2),
            spi=round(spi, 2),
            cpi=round(cpi, 2),
            eac=round(eac, 2),
            etc=round(etc, 2),
            vac=round(vac, 2)
        )

    def get_monthly_cash_flow(self) -> pd.DataFrame:
        """Aggregate cash flow by month."""

        daily = self.generate_cash_flow()
        if daily.empty:
            return pd.DataFrame()

        daily['Month'] = pd.to_datetime(daily['Date']).dt.to_period('M')
        monthly = daily.groupby('Month').agg({
            'Daily': 'sum',
            'Cumulative': 'last'
        }).reset_index()

        monthly.columns = ['Month', 'Monthly Cost', 'Cumulative']
        return monthly

    def export_to_excel(self, output_path: str) -> str:
        """Export integrated data to Excel."""

        with pd.ExcelWriter(output_path, engine='openpyxl') as writer:
            # Cost-loaded schedule
            schedule = self.generate_cost_loaded_schedule()
            schedule.to_excel(writer, sheet_name='Cost-Loaded Schedule', index=False)

            # Cash flow
            cash_flow = self.generate_cash_flow()
            if not cash_flow.empty:
                cash_flow.to_excel(writer, sheet_name='Cash Flow', index=False)

            # Monthly
            monthly = self.get_monthly_cash_flow()
            if not monthly.empty:
                monthly.to_excel(writer, sheet_name='Monthly', index=False)

            # Earned Value
            evm = self.calculate_earned_value(date.today())
            evm_df = pd.DataFrame([{
                'Data Date': evm.data_date,
                'BCWS (PV)': evm.bcws,
                'BCWP (EV)': evm.bcwp,
                'ACWP (AC)': evm.acwp,
                'SV': evm.sv,
                'CV': evm.cv,
                'SPI': evm.spi,
                'CPI': evm.cpi,
                'EAC': evm.eac,
                'ETC': evm.etc,
                'VAC': evm.vac
            }])
            evm_df.to_excel(writer, sheet_name='Earned Value', index=False)

        return output_path
```

## Quick Start

```python
from datetime import date, timedelta

# Initialize linker
linker = ScheduleCostLinker("Office Building", budget_at_completion=5000000)

# Add activities
linker.add_activity("A-001", "Foundation", date(2024, 6, 1), date(2024, 6, 30), percent_complete=100)
linker.add_activity("A-002", "Structure", date(2024, 7, 1), date(2024, 9, 30), percent_complete=60)
linker.add_activity("A-003", "MEP", date(2024, 8, 1), date(2024, 11, 30), percent_complete=30)

# Add cost items
linker.add_cost_item("01-FOUND", "Foundation Work", 500000)
linker.add_cost_item("02-STRUCT", "Structural Work", 2000000)
linker.add_cost_item("03-MEP", "MEP Systems", 1500000)

# Link
linker.link_activity_cost("A-001", "01-FOUND")
linker.link_activity_cost("A-002", "02-STRUCT", LoadingMethod.BELL_CURVE)
linker.link_activity_cost("A-003", "03-MEP", LoadingMethod.BACK_LOADED)

# Record actuals
linker.record_actual_cost("A-001", 520000)
linker.record_actual_cost("A-002", 1300000)
```

## Common Use Cases

### 1. Earned Value Analysis
```python
evm = linker.calculate_earned_value(date.today())
print(f"CPI: {evm.cpi}")
print(f"SPI: {evm.spi}")
print(f"EAC: ${evm.eac:,.2f}")
```

### 2. Cash Flow Forecast
```python
cash_flow = linker.generate_cash_flow()
print(cash_flow.tail(10))
```

### 3. Monthly Breakdown
```python
monthly = linker.get_monthly_cash_flow()
print(monthly)
```

## Resources
- **DDC Book**: Chapter 4.2 - Schedule-Cost Integration

© datadrivenconstruction · MIT · datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction

Похожие скиллы

Все скиллы по теме «Настройка агента: память, контекст, субагенты» →
c-schedule daxaur Скилл c-schedule ставит повторяющиеся задачи Claude на launchd или cron, следит за расходом и отдаёт результат в Telegram, файл или уведомление. CX Codex +1 ★ 179звёзд репо gao-cost jgsystemsconsulting Скилл gao-cost для Claude Code помогает разрабатывать и проверять оценки стоимости программ. Используйте его для выбора метода расчёта, анализа рисков и связи оценки с управлением освоенной стоимостью. CX Codex +1 ★ 93звёзд репо cost-health ruvnet Скилл cost-health гоняет четыре проверки расходов параллельно и отдаёт один статус: бюджет, ускорение трат, аномалии сессий и прогноз исчерпания. CX Codex +1 249установок cost-accrual-tracker curiositech Скилл cost-accrual-tracker для Claude Code и пяти других платформ, который считает расходы на API в режиме реального времени во время выполнения LLM-запросов. Фиксирует частичные затраты даже при прерванных запросах. CX Codex +1 175установок cost-verification-auditor curiositech Скилл cost-verification-auditor для Claude Code сверяет оценку стоимости токенов с фактическими расходами по API. Запускается для поиска причины расхождения прогноза и счёта. CX Codex +1 175установок dd-audit-cost-spike-investigation datadog-labs Скилл dd-audit-cost-spike-investigation для Claude Code сопоставляет Usage Metering Datadog с изменениями в Audit Trail. При расследовании скачка расходов выявляет изменения за предшествующие 24 часа. CX Codex +1 560установок

Из того же набора156

Весь набор →
data-evolution-analysis Скилл data-evolution-analysis оценивает цифровую зрелость строительной компании по методике DDC от бумажного документооборота до предиктивной аналитики. Помогает составить дорожную карту цифровизации. CX Codex +1 118установок semantic-search-cwicr Скилл semantic-search-cwicr находит похожие позиции в строительных расценках DDC CWICR через векторный поиск на естественном языке. Работает с 8 национальными базами в 26 языках. CX Codex +1 118установок cwicr-risk-calculator Скилл cwicr-risk-calculator рассчитывает сметные риски и надбавки на непредвиденные расходы в строительстве с помощью симуляций Монте-Карло. CX Codex +1 118установок nobim-image-generator Скилл nobim-image-generator для Claude Code строит визуализации BIM-данных без BIM-программы. Запускается по запросу создать изображения или схемы из Revit- или IFC-модели. CX Codex +1 117установок payment-application-generator Скилл payment-application-generator генерирует платёжные заявки в формате AIA: ведёт график стоимости работ, считает удержания и выводит документы для оплаты. CX Codex +1 117установок erp-integration-analysis Скилл erp-integration-analysis разбирает потоки данных между модулями ERP в строительных организациях. Пригодится, чтобы найти узкие места интеграций и получить рекомендации по их настройке. CX Codex +1 117установок etl-pipeline Скилл etl-pipeline помогает собирать конвейеры для обработки строительных данных: извлекать их из файлов и систем, преобразовывать и выгружать в отчёты или базы. CX Codex +1 117установок payment-application-processor Скилл payment-application-processor обрабатывает платёжные акты в строительстве: проверяет график работ, рассчитывает удержания, отслеживает статус биллинга и генерирует формы G702/G703. Нужен Python 3. CX Codex +1 117установок

Спонсоры проекта

Компании, которые помогают держать аналитику открытой