Construction Claim Strategy

SKILL.md

---
name: construction-claim-strategy
description: Strategic planning framework for construction claim responses — plan direction, scope, arguments, and disclosure strategy BEFORE selecting clauses or drafting. Covers situation assessment, scope control, direction decisions, argument ranking, disclosure control, response architecture, and risk assessment for EOT, delay, disruption, variation, and payment claims under PSSCOC, FIDIC, NEC, SIA, and bespoke forms. Includes practical checklists, quantum calculation methods, ADR strategies, delay analysis methods, concurrent delay, disruption claims, arbitration tactics, expert engagement, notice compliance, and legal precedent guidance.
---

# Construction Claim Strategy

**Strategic planning framework for construction claim responses.**

Plan your direction, scope, arguments, and disclosure strategy **before** selecting clauses or drafting correspondence.

---

## Why use this?

- Stop jumping straight to clause selection — plan the strategy first.
- Rank arguments by strength (Textual Interpretation is strongest).
- Control what to disclose precisely, keep general, or defer.
- Choose proven response structures.
- Avoid common mistakes that weaken your position.

---

## Who this is for

- Contract managers
- Claims consultants
- Quantity surveyors
- Commercial managers
- Construction lawyers
- Anyone preparing responses to claims or formal queries under construction contracts

---

## What this skill does

Use this tool to systematically work through 7 key dimensions:

1. **Situation Assessment** — Understand exactly what you are responding to.
2. **Scope Control** — Decide what to address and what to avoid volunteering.
3. **Direction Decision** — Choose primary and fallback arguments, and what to avoid.
4. **Argument Strategy** — Select the strongest type of argument available.
5. **Disclosure Control** — Decide what to state precisely, keep general, or defer.
6. **Response Architecture** — Choose the most effective structure for your reply.
7. **Risk Assessment** — Identify counter-arguments, weak points, and timing risks.

Plus **practical tools and reference guides** covering:

- Record keeping checklists
- Claim preparation checklists (adjudication & arbitration)
- Notice requirements compliance
- Expert engagement guidance
- ADR strategy (negotiation, mediation, adjudication, arbitration)
- Concurrent delay strategic approach
- Disruption claims strategy
- Delay analysis methods (As-Planned vs As-Built, TIA, Collapsed As-Built, Windows)
- Arbitration tactics and prolongation strategies
- Quantum calculation worked examples (Eichleay, Hudson, Emden, Measured Mile, Actual Cost, Total Cost)
- Legal precedents overview (Prevention Principle, Common Law vs Civil Law)
- Common pitfalls and how to avoid them
- Risk assessment framework

---

## Supported contract forms

Works with any construction contract form:
- PSSCOC (Construction Works / D&B)
- FIDIC (Red, Yellow, Silver, Emerald)
- NEC (NEC3, NEC4)
- SIA Conditions
- JCT
- Bespoke contract conditions

---

## Working out the actual deadline

Most construction claim responses are time-bound. Before using this skill, identify the actual calendar deadline for your response.

For Singapore matters under the Building and Construction Industry Security of Payment Act (SOPA), or for contracts using calendar-day notice periods (PSSCOC, SIA, FIDIC, NEC), the deadline calculation is not just "today + N days". It must account for:

- **Calendar-day counting** — Saturdays count; Sundays and public holidays generally do not, per s.50(a) of the Interpretation Act
- **In-lieu Mondays** where a public holiday falls on a Sunday
- **Ad-hoc declared holidays** (e.g. Polling Day) which are not in the standard gazetted list

The companion skill **construction-law** includes a Singapore SOPA deadline calculator that handles these rules. Calculate the actual deadline there first, then provide the resulting date when prompted by this skill.

If your contract is governed by a different jurisdiction, apply the equivalent local rule. Do not assume "calendar day" means simple date arithmetic — it almost never does.

---

## Start here

### Quick Reference (all strategy patterns)

```bash
python3 scripts/strategy_advisor.py --reference
```

Outputs all argument types, disclosure levels, response patterns, scope control rules, and risk checklists in one view.

### Interactive Strategy Session (Recommended)

```bash
python3 scripts/strategy_advisor.py
```

The wizard walks you through all 7 dimensions and produces a structured strategy report.

### Non-Interactive (from JSON)

```bash
python3 scripts/strategy_advisor.py --file strategy_input.json --output strategy_report.md
```

### Save Strategy for Reuse

```bash
python3 scripts/strategy_advisor.py --save-strategy my_strategy.json
```

---

## Examples

The `examples/` folder contains a worked scenario demonstrating the full 7-Dimension workflow:

| File | Description |
|------|-------------|
| `strategy_input.json` | Sample JSON input — PSSCOC 2014 (7th Edition) EOT scenario |
| `strategy_report_sample.md` | Generated strategy report from the above input |

**Note:** The example uses **PSSCOC 2014** clause references (Clauses 12.5, 14.2(m), 14.2(n), 22.1(h), 22.1(i), 14.3, 23.1). The **7-Dimension methodology itself is contract-form neutral** — it applies equally to FIDIC, NEC, SIA, JCT, and bespoke contracts. Future versions will include additional worked examples for other contract forms.

---

## Key Concepts

### Argument Strength Ranking

1. **Textual Interpretation** (Strongest) — Argue from the actual wording of the relevant clause in the Contract.
2. **Factual Distinction** (Strong) — Show that the facts fall outside the clause's scope or trigger conditions.
3. **Concede-then-Distinguish** (Moderate-Strong) — Acknowledge the normal case, then distinguish the current situation.
4. **Implied Terms** (Weakest) — Use only as a last resort when no express clause wording supports the position.

### Disclosure Control Levels

| Level | Use for |
|-------|---------|
| **State Precisely** | Clause references, formal correspondence, key dates, and legal reasoning |
| **Keep General** | Operational context and high-level details |
| **Defer** | Detailed quantification and supporting analysis |

### Recommended Response Patterns

- **Standard Query Response** — acknowledge, pivot, argue, reserve, close
- **Risk Allocation Rebuttal** — concede ordinary application, distinguish, factual support, legal conclusion, mitigation evidence, close cooperatively
- **Chronology-Based Response** — state known facts, flag pending items, commit to supplement, reserve
- **Cost / Quantum Claim Response** — contractual basis, heads of claim, ongoing assessment, commit to detailed breakdown, reserve
- **Reservation of Rights Closing** — always recommended

### Scope Control Rules

1. **Limit to letter** — respond only to what was asked; do not volunteer unrequested information.
2. **Preserve future claims** — use "reserves its position" and "without prejudice" language.
3. **Keep operational details general** — do not name specific zones or quantities prematurely.

### Common Anti-Patterns to Avoid

- ❌ Citing the wrong clause (e.g., a clause for other contractors when the Employer caused the issue)
- ❌ Leading with "the clause doesn't apply" — this antagonises the other party
- ❌ Volunteering information about topics not yet raised
- ❌ Naming specific zones/quantities before they are finalised
- ❌ Reaching for implied terms when express clause text supports your case
- ❌ Hedging dates that have formal letter references behind them
- ❌ Quantifying costs before records are complete

---

## How to use

### CLI options

```
usage: strategy_advisor [-h] [--file INPUT_JSON] [--output FILE]
                        [--format {md,txt}] [--save-strategy PATH]
                        [--reference] [--version]

Strategy Advisor — Strategic planning framework for construction claim
responses. Plan your direction, scope, and argument strategy BEFORE selecting
clauses.

options:
  -h, --help            show this help message and exit
  --file INPUT_JSON     Non-interactive: read strategy inputs from a JSON
                        file.
  --output, -o FILE     Write report to file instead of stdout.
  --format, -f {md,txt}
                        Output format (default: md).
  --save-strategy PATH  Save the strategy data as JSON for reuse.
  --reference           Print all reference tables (argument types, patterns,
                        etc.) and exit.
  --version             show program's version number and exit
```

### Required JSON keys (for `--file` mode)

The following 6 keys are **required** in the input JSON. If any are missing, the tool exits with a clear error listing what’s needed.

| Key | Description |
|-----|-------------|
| `situation_type` | What you’re dealing with (e.g. “Responding to a rejection of our claim”) |
| `other_side_position` | The other party’s stated position |
| `trigger_event` | Key facts / what triggered this response |
| `primary_argument` | Your primary contractual argument |
| `chosen_argument_type` | Argument type (e.g. “Textual Interpretation”) |
| `chosen_pattern` | Response architecture pattern (e.g. “Risk Allocation Rebuttal”) |

All other keys are optional — the tool fills empty fields gracefully. See `examples/strategy_input.json` for a complete example with all 21 supported keys.

### Commands

```bash
# Show all reference tables
python3 scripts/strategy_advisor.py --reference

# Run interactive wizard
python3 scripts/strategy_advisor.py

# Non-interactive from JSON
python3 scripts/strategy_advisor.py --file input.json --output report.md

# Save strategy for reuse
python3 scripts/strategy_advisor.py --save-strategy strategy.json
```

---

## Reference Library

All reference documents are in the `references/` folder. These are standalone reading material for human use — the `strategy_advisor.py` script does not load them at runtime.

| Document | Description |
|----------|-------------|
| `seven_dimensions_guide.md` | Full guide to the 7-Dimension framework |
| `argument_ranking_guide.md` | Detailed argument types with examples |
| `worked_examples.md` | 4 complete worked strategy examples (Variation, EOT, Disruption, Combined) |
| `delay_analysis_study_guide.md` | Comprehensive delay analysis study guide — SCL Protocol 22 principles, 7 analysis methods, concurrent delay, pacing, float, disruption, force majeure, case law |
| `quantum_worked_examples.md` | 8 quantum calculation examples (Eichleay, Hudson, Emden, Measured Mile, Actual Cost, Total Cost) |
| `adr_overview.md` | ADR methods comparison and strategy recommendations |
| `arbitration_tactics.md` | Arbitration tactics and prolongation claim strategies |
| `concurrent_delay.md` | Concurrent delay — strategic approach within the 7-Dimension framework |
| `disruption_claims.md` | Disruption claims strategy — Common Law vs Civil Law |
| `delay_analysis_methods.md` | Delay analysis methods — strategic overview |
| `legal_precedents.md` | Legal precedents and the Prevention Principle |
| `notice_requirements_checklist.md` | Notice compliance checklist |
| `expert_engagement.md` | Expert engagement tips and best practices |
| `record_keeping_checklist.md` | Printable record keeping checklist |
| `claim_preparation_checklist.md` | Claim preparation checklist for adjudication & arbitration |
| `common_pitfalls.md` | 10 most common claim pitfalls and how to avoid them |
| `risk_assessment_framework.md` | Expanded risk assessment categories and practical questions |
| `response_template.md` | Letter template mapping strategy to formal response |
| `quick_reference_card.md` | One-page desk reference card |
| `blank_worksheet.md` | Printable blank 7-Dimension worksheet |
| `training_guide.md` | Workshop-ready training material |
| `strategy_patterns.md` | All strategy patterns reference |

---

## How to use with the construction-law companion skill

This skill is designed to pair with **construction-law**, which handles clause analysis, notice drafting, and deadline calculation. The typical end-to-end workflow uses both skills in sequence:

1. **Identify the applicable clause and notice period** — use construction-law to look up the relevant contract clause (e.g. EOT notice provision, SOPA payment response window) and the prescribed time limit.

2. **Calculate the actual deadline** — use construction-law’s SOP calculator (or its equivalent for your contract form) to compute the calendar date, accounting for weekends, public holidays, and statutory roll-forward rules. Do not rely on simple date arithmetic.

3. **Plan the response strategy** — use this skill to work through the 7 strategy dimensions. Pass the calculated deadline as the `response_deadline` input.

4. **Draft the response** — return to construction-law for clause-level drafting and formal correspondence templates, using the strategy from step 3 as input.

Keeping strategy and execution in separate skills produces more commercially realistic outputs than trying to combine them. Each skill stays focused on what it does well: this one decides the direction; construction-law executes the analysis and drafting.

---

## Requirements

- Python 3.10+
- Standard library only — no third-party dependencies

## Tests

```bash
python3 -m unittest tests.test_smoke
```

---
## Security & Safety

- ✅ No network access
- ✅ No external calls
- ✅ No subprocess execution
- ✅ No dynamic code loading
- ✅ No telemetry: this tool does not collect or transmit usage data
- ✅ Safe for use with confidential project information
- ✅ **Safe to install and use** 🛡️

### Files written

This tool writes files **only** when you pass explicit flags:

| Flag | What is written | Format |
|------|----------------|--------|
| `--output FILE` | Strategy report | UTF-8 (Markdown or plain text) |
| `--save-strategy PATH` | Strategy data for reuse | UTF-8 JSON |

If neither flag is provided, output is printed to stdout. No files are created, modified, or read beyond the `--file` input (when given).

---

## Changelog

### v1.7.6 (May 2026)
- **Docs:** Added "Working out the actual deadline" section — explains calendar-day counting, s.50(a) roll-forward, ad-hoc holidays; points users to construction-law SOP calculator before running strategy
- **Docs:** Replaced "Companion skill" section with "How to use with construction-law" — 4-step end-to-end workflow (identify clause → calculate deadline → plan strategy → draft response)
- **Wizard:** Response deadline prompt sharpened to nudge toward specific calendar dates and reference the SOP calculator
- **Design decision:** No cross-skill code coupling. Date math stays in construction-law; strategy planning stays here. Skills are paired via documentation, not imports.

### v1.7.5 (May 2026)
- **Security:** Sanitised test docstrings and comments — removed function-call patterns (e.g. `compile(...)`) that ClawHub static analysis flagged as `suspicious.dynamic_code_execution`. The actual detection logic uses `ast.parse` and was never affected; the scanner was pattern-matching against English text in comments.

### v1.7.4 (May 2026)
- **Security:** Replaced string-grep forbidden-imports check with `ast.parse` tree-walking — properly catches `compile(...)`, `exec(...)`, `eval(...)` regardless of whitespace or indirection; no longer false-positives on comments, docstrings, or strings containing those words

### v1.7.3 (May 2026)
- **Security:** Rewrote `test_smoke.py` to avoid `subprocess.run()` entirely — now imports `main()` directly and patches `sys.argv`. Resolves ClawHub ClawScan `suspicious.dynamic_code_execution` false positive on the test file
- **Security:** Tightened forbidden-imports list: `urllib.request`/`urllib.error` (not blanket `urllib`), added `importlib`, `pickle`, `marshal`, `compile(`
- **Performance:** Tests now run in ~0.01s (was ~0.2s with subprocess overhead)

### v1.7.2 (May 2026)
- **Fix:** Interactive mode now wraps file writes (`--output`, `--save-strategy`) with friendly error messages (consistent with non-interactive mode)
- **Added:** Required-key validation for `--file` JSON input — missing keys produce a clear error listing what's needed, instead of empty fields
- **Added:** `_safe_write` helper — unified error handling for all file output paths
- **Docs:** Added `--help` output to SKILL.md so users can evaluate CLI flags without installing
- **Docs:** Added explicit "No telemetry" statement in Security section
- **Docs:** Added "Files written" section documenting exactly what is written and when
- **Docs:** Documented the 6 required JSON keys for `--file` mode
- **Docs:** Changed test instructions to recommend `python3 -m unittest` (stdlib) over `pytest`

### v1.7.1 (May 2026)
- **Security:** Added `test_no_forbidden_imports` — enforces the "no network / no subprocess" claim at test time by scanning for forbidden imports (subprocess, socket, requests, urllib, etc.)
- **Compatibility:** Updated Python requirement from 3.6+ to 3.10+ (reflects what is actually tested)

### v1.7.0 (May 2026)
- **Changed:** Replaced example scenario with a realistic PSSCOC EOT case (Contractor responding to SO rejection under Clause 13.2)
- **Changed:** `strategy_input.json` rewritten with correct flat-key schema matching all 7 dimensions
- **Changed:** `strategy_report_sample.md` regenerated from actual script output (not hand-written)
- **Changed:** Improved test docstrings and header matching

### v1.6.1 (May 2026)
- **Added:** JSON input validation for `--file` mode — checks file exists, valid JSON, root is a dict; warns on unrecognised keys (typo protection)
- **Added:** File I/O error handling — friendly messages for missing files, permission errors, and malformed JSON (no raw tracebacks)
- **Removed:** Dead code (`_prompt_yesno` function was defined but never called)

### v1.6.0 (May 2026)
- **Added:** `examples/strategy_input.json` and `examples/strategy_report_sample.md` — preview output before installing
- **Added:** `tests/test_smoke.py` — smoke test covering `--reference`, `--file`, and `--version` modes
- **Added:** `LICENSE` file (MIT-0) shipped at package root
- **Added:** Requirements section in SKILL.md (Python 3.6+, stdlib only)
- **Added:** Tests section in SKILL.md
- **Changed:** Vocabulary normalisation — replaced contract-form-specific terms ("Authority", "Engineer") with neutral language ("certifier", "the other party") for consistent applicability across PSSCOC, FIDIC, NEC, SIA, JCT, and bespoke contracts
- **Changed:** SKILL.md clarifies that `references/` is human reading material, not loaded by the script at runtime
- **Fixed:** Removed stale reference to `construction_law.py` in module docstring
- **Fixed:** Removed dead conditional branch in title block of `generate_report`

### v1.5.0 (May 2026)
- **Added:** Delay Analysis Study Guide — comprehensive reference covering SCL Protocol 22 Core Principles, 7 delay analysis methods (incl. Retrospective Longest Path), negative float & EOT entitlement, concurrent delay (Malmaison, North Midland, City Inn), pacing delays, disruption causation (Walter Lilly test), force majeure vs hardship, COVID-19 lessons, 15 key cases, and full definitions glossary
- Sanitised from project-specific study guide; all generic content with public case law citations
- Total reference documents: 22

### v1.4.0 (May 2026)
- **Major expansion:** Integrated full Construction Claim Strategy Practical Tools Guide v1.4
- Added: Notice Requirements Checklist
- Added: Expert Engagement Tips
- Added: Legal Precedents guide (Prevention Principle, Common Law vs Civil Law)
- Added: Concurrent Delay — Strategic Approach
- Added: Disruption Claims Strategy (with Common Law vs Civil Law comparison)
- Added: Delay Analysis Methods — Strategic Overview (As-Planned vs As-Built, TIA, Collapsed As-Built, Windows)
- Added: Arbitration Tactics & Prolongation Claim Strategies
- Added: ADR Overview with Adjudication vs Arbitration detailed comparison
- Added: Quantum Calculation Worked Examples (8 examples: Eichleay, Hudson, Emden, 2× Measured Mile, Actual Cost, Productivity Loss, Total Cost)
- Added: Common Claim Pitfalls (10 pitfalls with fixes)
- Added: Risk Assessment Framework (expanded categories and practical questions)
- Added: Record Keeping Checklist (printable)
- Added: Claim Preparation Checklist (printable, adjudication & arbitration)
- Total reference documents: 21

### v1.3.0 (May 2026)
- Added argument ranking guide, seven dimensions guide, worked examples
- Added response template, quick reference card, blank worksheet
- Added training guide and strategy patterns

### v1.1.0 (May 2026)
- Fully sanitized — all examples use generic/neutral language
- Improved interactive wizard with examples and input validation
- Better README for public listing
- Added review step before report generation

### v1.0.1 (May 2026)
- Removed all project-specific references
- Added disclaimer

### v1.0.0 (May 2026)
- Initial release — 7 strategy dimensions
- Interactive wizard mode
- Non-interactive JSON mode
- Reference tables dump
- Strategy save/reload

---

*This is a generic strategic planning tool. It does not constitute legal advice. Users should verify all information independently and seek qualified legal counsel before relying on any analysis for dispute resolution, adjudication, arbitration, or court proceedings.*