pre-mortem

Scan engine phases for silent failures before a cycle run.

1|Updated Jan 15, 2026
One-click install
npx skills add https://github.com/pnils08/GodWorld --skill pre-mortem-pnils08
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: pre-mortem
Source: https://github.com/pnils08/GodWorld/tree/main/.claude/skills/pre-mortem
Command: npx skills add https://github.com/pnils08/GodWorld --skill pre-mortem-pnils08

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps engineering teams prevent cascading failures by proactively scanning all engine phases prior to a cycle run. It validates dependency flow between ctx fields, checks for proper sheet headers, detects risky code patterns, and flags cascade risks that could derail cycle execution.

Core Features & Use Cases

  • ctx field dependency verification across Phase 5 sub-engines and related phases to ensure data is written before it is read.
  • Sheet header alignment and write-pattern validation across phase directories to prevent silent data loss.
  • Detection of deterministic programming issues, including Math.random() usage, that could affect reproducibility.
  • Neighborhood reference validation to ensure only canonical Oakland districts are referenced.
  • Write-intent target validation to confirm target sheets exist and are writable.
  • Timely risk reporting that produces a structured report highlighting file:line references and recommended mitigations.

Quick Start

Run the pre-mortem scan before starting a new cycle to generate a risk report and catch potential cascading failures early.

Frequently Asked Questions about pre-mortem

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I detect silent engine failures before running a cycle?

To prevent silent engine failures before a cycle run, scan all phase engines to detect ctx dependency violations, header misalignments, and risky code patterns like Math.random usage. This generates a structured risk report with file:line references for early mitigation.

What is ctx field dependency verification and how does it work across engine phases?

Ctx field dependency verification checks data flow across Phase 5 sub-engines and related phases to ensure ctx fields are written before they are read. This prevents cascading failures caused by out-of-order data access during cycle execution.

How do I validate sheet headers and write patterns across phase directories?

Validate sheet headers and write patterns by scanning phase directories for alignment issues and restricted sheet write actions. This pre-mortem check prevents silent data loss by confirming write targets exist, are writable, and match expected headers.

Does this pre-mortem scan check for Math.random usage and determinism issues in phase engines?

Yes, the pre-mortem scan detects deterministic programming issues including Math.random usage across Phase01-config through Phase10-persistence. It flags these risky code patterns to ensure cycle reproducibility and prevent silent execution failures.

Can I use this scan to validate neighborhood references and write-intent targets?

Yes, you can validate neighborhood references to ensure only canonical Oakland districts are referenced, and verify write-intent targets to confirm target sheets exist and are writable. These checks run across all phase engines before cycle execution.

What limitations exist when scanning phase engines for cascading failure risks?

The scan is limited to detecting known risk patterns across Phase01-config through Phase10-persistence, including ctx flow ordering, header misalignments, and Math.random usage. It produces a risk report but does not execute or modify the cycle run itself.