Skip to content

amazon-science/ammo / ai_cli_session/.codex/skills/ammo

Profile and optimize GPU kernels for vLLM inference on NVIDIA GPUs. Use when targeting a specific model, hardware, dtype, parallelism, and workload to improve latency.

FileKindSize
RUNTIME.mdmarkdown4.9 KB
SKILL.mdskill md18.5 KB
agents/ammo-auditor.mdmarkdown9.1 KB
agents/ammo-champion.mdmarkdown9.6 KB
agents/ammo-delegate.mdmarkdown3.2 KB
agents/ammo-implementer.mdmarkdown13.8 KB
agents/ammo-investigator.mdmarkdown4.0 KB
agents/ammo-report.mdmarkdown2.9 KB
agents/ammo-researcher.mdmarkdown10.3 KB
agents/ammo-resolver.mdmarkdown4.4 KB
agents/ammo-transcript-monitor.mdmarkdown7.8 KB
agents/openai.yamlexecutablescript313 B
data/ATTRIBUTION.mdmarkdown1.4 KB
data/gsm8k_full.jsonexecutablescript735.5 KB
data/gsm8k_subset.jsonexecutablescript116.8 KB
eval/EVAL-SKILL.mdexecutablescript21.8 KB
eval/agents/transcript_grader.mdexecutablescript18.0 KB
eval/causal/__init__.pyexecutablescript137 B
eval/causal/agents/causal_analyzer.mdexecutablescript10.5 KB
eval/causal/build_dag.pyexecutablescript21.6 KB
eval/causal/diff_versions.pyexecutablescript38.5 KB
eval/causal/extract_events.pyexecutablescript36.3 KB
eval/causal/generate_postmortem.pyexecutablescript17.0 KB
eval/causal/score_nodes.pyexecutablescript21.5 KB
eval/causal/templates/narrative_template.mdexecutablescript472 B
eval/causal/templates/viz_template.htmlexecutablescript9.5 KB
eval/causal/tests/__init__.pyexecutablescript151 B
eval/causal/tests/conftest.pyexecutablescript448 B
eval/causal/tests/fixtures/sample_session.jsonlexecutablescript10.4 KB
eval/causal/tests/fixtures/sample_session_data.jsonexecutablescript3.4 KB
eval/causal/tests/fixtures/sample_snapshot.jsonexecutablescript2.5 KB
eval/causal/tests/test_build_dag.pyexecutablescript2.7 KB
eval/causal/tests/test_diff_versions.pyexecutablescript13.5 KB
eval/causal/tests/test_extract_events.pyexecutablescript3.7 KB
eval/causal/tests/test_generate_postmortem.pyexecutablescript3.1 KB
eval/causal/tests/test_score_nodes.pyexecutablescript3.3 KB
eval/scripts/aggregate_versions.pyexecutablescript15.2 KB
eval/scripts/archive_run.pyexecutablescript9.1 KB
eval/scripts/codex_session.pyexecutablescript10.6 KB
eval/scripts/generate_dashboard.pyexecutablescript5.3 KB
eval/scripts/parse_artifacts.pyexecutablescript48.1 KB
eval/scripts/parse_session_logs.pyexecutablescript51.3 KB
eval/scripts/rescore_archived.pyexecutablescript5.5 KB
eval/scripts/score_campaign.pyexecutablescript43.8 KB
eval/scripts/snapshot_changes.pyexecutablescript11.1 KB
eval/scripts/verify_citations.pyexecutablescript8.8 KB
eval/tests/test_dashboard_bugs.pyexecutablescript8.8 KB
eval/tests/test_parse_session_logs.pyexecutablescript3.9 KB
eval/tests/test_parse_session_logs_round_inference.pyexecutablescript11.0 KB
eval/tests/test_score_campaign_diluted.pyexecutablescript9.4 KB
eval/viewer/dashboard_template.htmlexecutablescript15.1 KB
instrumentation/sitecustomize.pyexecutablescript3.6 KB
orchestration/audit-protocol.mdmarkdown9.3 KB
orchestration/debate-protocol.mdmarkdown11.2 KB
orchestration/integration-logic.mdmarkdown10.3 KB
orchestration/parallel-tracks.mdmarkdown8.9 KB
references/artifact-layout.mdexecutablescript22.4 KB
references/audit-invariants.mdmarkdown10.6 KB
references/champion-common-patterns.mdmarkdown3.4 KB
references/crossover-probing.mdexecutablescript4.7 KB
references/cudagraph-safety.mdmarkdown2.7 KB
references/debate-rules.mdmarkdown4.7 KB
references/debate-scoring-rubric.mdexecutablescript16.7 KB
references/e2e-delta-math.mdexecutablescript17.9 KB
references/e2e-latency-guide.mdexecutablescript9.6 KB
references/fusion-feasibility-heuristics.mdmarkdown5.6 KB
references/gpu-pool.mdexecutablescript5.4 KB
references/impl-track-rules.mdexecutablescript13.8 KB
references/nsys-profiling-guide.mdmarkdown9.8 KB
references/optimization-categories.mdexecutablescript11.0 KB
references/shutdown-protocol.mdexecutablescript3.1 KB
references/technology-selection.mdmarkdown5.0 KB
references/torch-compile-contract.mdmarkdown13.8 KB
references/validation-defaults.mdexecutablescript34.2 KB
references/workload-invocation.mdexecutablescript4.9 KB
references/writing-style.mdexecutablescript6.9 KB
scripts/ammo_state.pyexecutablescript142.0 KB
scripts/artifact_layout.jsonconfig16.3 KB
scripts/check_projection_accuracy.pyexecutablescript11.7 KB
scripts/create_evidence_template.pyexecutablescript9.7 KB
scripts/create_worktree_with_build.shexecutablescript10.2 KB
scripts/generate_validation_report.pyexecutablescript35.7 KB
scripts/gpu_reservation.pyexecutablescript27.1 KB
scripts/hook_cmd_classify.pyscript13.3 KB
scripts/mine_trace.pyscript29.4 KB
scripts/monitor_queue_ack.pyexecutablescript6.1 KB
scripts/ncu_sanity.shexecutablescript5.2 KB
scripts/ncu_sanity_driver.pyexecutablescript8.5 KB
scripts/new_target.pyexecutablescript22.0 KB
scripts/preflight_vllm_api.pyexecutablescript12.3 KB
scripts/reconcile_track_state.pyexecutablescript15.8 KB
scripts/remove_worktree_cleanup.shexecutablescript1.1 KB
scripts/resolve_codex_transcript.pyexecutablescript3.6 KB
scripts/run_vllm_bench_latency_sweep.pyexecutablescript249.6 KB
scripts/transcript_filter.pyexecutablescript38.4 KB
scripts/transitions.jsonexecutablescript1.5 KB
scripts/verify_validation_gates.pyexecutablescript88.8 KB
tests/agents/test-champion.mdexecutablescript20.4 KB
tests/agents/test-impl-champion.mdexecutablescript14.3 KB
tests/agents/test-implementer.mdexecutablescript15.8 KB
tests/agents/test-orchestrator.mdexecutablescript33.8 KB
tests/agents/test-researcher.mdexecutablescript21.0 KB
tests/agents/test-transcript-monitor.mdexecutablescript13.4 KB
tests/fixtures/diluted_pass/legacy_no_phase.golden.mdmarkdown1.1 KB
tests/fixtures/diluted_pass/legacy_no_phase.golden.summary.jsonconfig582 B
tests/fixtures/diluted_pass/legacy_no_phase.jsonconfig400 B
tests/fixtures/diluted_pass/legacy_scalar_phase.golden.mdmarkdown2.0 KB
tests/fixtures/diluted_pass/legacy_scalar_phase.golden.summary.jsonconfig1.0 KB
tests/fixtures/diluted_pass/legacy_scalar_phase.jsonconfig626 B
tests/fixtures/mining/real_campaign_bottleneck_analysis.mdmarkdown20.7 KB
tests/run_all.shexecutablescript1.6 KB
tests/scripts/test_transcript_filter.pyexecutablescript41.1 KB
tests/test_agent_runtime_contracts.pyexecutablescript1.8 KB
tests/test_ammo_state.pyexecutablescript71.7 KB
tests/test_artifact_layout_manifest.pyscript11.6 KB
tests/test_audit_started.pyscript18.2 KB
tests/test_correctness_comparator.pyscript12.6 KB
tests/test_diluted_pass.pyscript24.4 KB
tests/test_drift_compat.pyscript5.1 KB
tests/test_evidence_freshness.pyexecutablescript5.6 KB
tests/test_fail_closed.pyexecutablescript14.7 KB
tests/test_gpu_reservation.pyexecutablescript24.8 KB
tests/test_gpu_reservation_session_id.pyexecutablescript11.2 KB
tests/test_guidance_semantic_contract.pyscript24.9 KB
tests/test_hook_cmd_classify_parity.pyscript11.7 KB
tests/test_hook_semantics.pyexecutablescript95.3 KB
tests/test_mine_trace.pyscript24.2 KB
tests/test_mining_invalidated_schema.pyexecutablescript9.4 KB
tests/test_new_target_dp_ep.pyexecutablescript7.4 KB
tests/test_new_target_v2_scaffold.pyexecutablescript13.1 KB
tests/test_parse_artifacts.pyexecutablescript3.0 KB
tests/test_policy_convergence.pyscript797 B
tests/test_preflight_vllm_api.pyscript13.3 KB
tests/test_projection_accuracy_v2.pyexecutablescript4.1 KB
tests/test_reconcile_track_state.pyexecutablescript18.2 KB
tests/test_resolve_codex_transcript.pyexecutablescript3.1 KB
tests/test_state_schema_semantics.pyexecutablescript7.6 KB
tests/test_status_set_sync.pyexecutablescript9.1 KB
tests/test_sweep_baseline_from_arm.pyscript11.0 KB
tests/test_sweep_decode_capture.pyexecutablescript31.8 KB
tests/test_sweep_dp.pyexecutablescript45.4 KB
tests/test_sweep_fresh_cache.pyscript5.5 KB
tests/test_sweep_profiler_guard.pyscript22.6 KB
tests/test_sweep_real_prompts.pyscript20.1 KB
tests/test_sweep_refactor.pyexecutablescript37.6 KB
tests/test_sweep_round_slot.pyexecutablescript7.4 KB
tests/test_validation_report_phase_triage.pyexecutablescript10.0 KB
tests/test_validation_report_v2.pyexecutablescript6.2 KB
tests/test_verify_validation_gates.pyexecutablescript52.9 KB
tests/test_workload_matrix.pyexecutablescript19.3 KB

eval/causal/generate_postmortem.py

View on GitHub
#!/usr/bin/env python3
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: CC-BY-NC-4.0
"""Generate a causal post-mortem narrative + interactive DAG visualization.

Reads a scored DAG (from score_nodes.py), an events list (from extract_events.py),
and an optional deep-analysis list (from a causal_analyzer agent) to produce:
  - A narrative Markdown report with critical path, anomalies, and recommendations.
  - An interactive HTML visualization of the DAG using dagre-d3.
  - An enriched DAG JSON with summary fields populated.

Usage:
    python generate_postmortem.py \\
        --scored-dag /path/to/scored_dag.json \\
        --events /path/to/events.json \\
        --output-dag /path/to/final_dag.json \\
        --output-narrative /path/to/postmortem.md \\
        --output-viz /path/to/viz.html \\
        [--deep-analysis /path/to/deep_analysis.json]
"""

from __future__ import annotations

import argparse
import json
import sys
from copy import deepcopy
from pathlib import Path
from typing import Any, Dict, List, Optional, Tuple


# ---------------------------------------------------------------------------
# Path helpers
# ---------------------------------------------------------------------------

_CAUSAL_DIR = Path(__file__).parent
_TEMPLATES_DIR = _CAUSAL_DIR / "templates"


def _read_template(name: str) -> str:
    """Read a template file from the templates directory."""
    path = _TEMPLATES_DIR / name
    return path.read_text(encoding="utf-8")


# ---------------------------------------------------------------------------
# Critical path computation
# ---------------------------------------------------------------------------

def _node_pipeline_pos(node_id: str) -> int:
    """Return a coarse pipeline position for a node ID."""
    _ORDER = ["bottleneck_mining", "baseline_capture", "debate"]
    if node_id in _ORDER:
        return _ORDER.index(node_id)
    if node_id.startswith("impl_"):
        return len(_ORDER)
    if node_id == "integration":
        return len(_ORDER) + 100
    if node_id == "campaign_eval":
        return len(_ORDER) + 200
    return len(_ORDER) + 50


def _compute_critical_path(nodes: List[Dict[str, Any]], edges: List[Dict[str, Any]]) -> List[str]:
    """Compute critical path via DP on topologically sorted nodes.

    Node weight = output_influence metric (fallback 0.5 if absent).
    Critical path = sequence from first to last node maximizing cumulative weight.

    Returns a list of node IDs in order.
    """
    if not nodes:
        return []

    # Sort nodes by event_range.start_idx (topological order approximation)
    sorted_nodes = sorted(
        nodes,
        key=lambda n: (n.get("event_range", {}).get("start_idx", 0), _node_pipeline_pos(n["id"])),
    )

    node_ids = [n["id"] for n in sorted_nodes]
    node_index = {nid: i for i, nid in enumerate(node_ids)}

    # Node weight from output_influence metric
    def _weight(n: Dict[str, Any]) -> float:
        metrics = n.get("metrics") or {}
        oi = metrics.get("output_influence")
        return float(oi) if oi is not None else 0.5

    # Build adjacency list from edges (forward only: from lower to higher index)
    adj: Dict[str, List[str]] = {nid: [] for nid in node_ids}
    for edge in edges:
        frm = edge.get("from")
        to = edge.get("to")
        if frm and to and frm in node_index and to in node_index:
            if node_index[frm] < node_index[to]:
                adj[frm].append(to)

    # DP: dist[i] = max cumulative weight ending at node i
    # prev[i] = predecessor node_id on best path to i
    dist: Dict[str, float] = {nid: 0.0 for nid in node_ids}
    prev: Dict[str, Optional[str]] = {nid: None for nid in node_ids}

    for nid in node_ids:
        w = _weight(next(n for n in nodes if n["id"] == nid))
        # Initialize: path consisting of just this node
        if dist[nid] == 0.0:
            dist[nid] = w

        for neighbor in adj.get(nid, []):
            candidate = dist[nid] + _weight(next(n for n in nodes if n["id"] == neighbor))
            if candidate > dist[neighbor]:
                dist[neighbor] = candidate
                prev[neighbor] = nid

    # Find end node with max dist
    best_end = max(node_ids, key=lambda nid: dist[nid])

    # Reconstruct path
    path = []
    cur: Optional[str] = best_end
    while cur is not None:
        path.append(cur)
        cur = prev[cur]
    path.reverse()

    # If path has only 1 node (all isolated), return all nodes sorted
    if len(path) < 2:
        return node_ids

    return path


# ---------------------------------------------------------------------------
# Merge deep analysis into DAG nodes
# ---------------------------------------------------------------------------

def _merge_deep_analysis(
    nodes: List[Dict[str, Any]],
    deep_analysis: Optional[List[Dict[str, Any]]],
) -> None:
    """Attach deep_analysis entries to matching nodes in-place."""
    if not deep_analysis:
        for node in nodes:
            node.setdefault("deep_analysis", None)
        return

    da_by_node: Dict[str, Dict[str, Any]] = {}
    for entry in deep_analysis:
        nid = entry.get("node_id")
        if nid:
            da_by_node[nid] = entry

    for node in nodes:
        nid = node["id"]
        if nid in da_by_node:
            node["deep_analysis"] = da_by_node[nid]
        else:
            node.setdefault("deep_analysis", None)


# ---------------------------------------------------------------------------
# Trajectory-changing decisions
# ---------------------------------------------------------------------------

def _find_trajectory_decisions(
    nodes: List[Dict[str, Any]],
    edges: List[Dict[str, Any]],
) -> List[Dict[str, Any]]:
    """Find nodes that have anomalies and at least one outgoing edge."""
    nodes_with_outgoing = set(edge.get("from") for edge in edges if edge.get("from"))

    decisions = []
    for node in nodes:
        anomaly = node.get("anomaly") or []
        if anomaly and node["id"] in nodes_with_outgoing:
            decisions.append({
                "node_id": node["id"],
                "anomaly_types": anomaly,
                "outgoing_count": sum(1 for e in edges if e.get("from") == node["id"]),
            })
    return decisions


# ---------------------------------------------------------------------------
# Collect actionable fixes from deep_analysis
# ---------------------------------------------------------------------------

def _collect_fixes(nodes: List[Dict[str, Any]]) -> List[str]:
    """Gather unique actionable_fix strings from deep_analysis fields."""
    fixes = []
    seen = set()
    for node in nodes:
        da = node.get("deep_analysis")
        if not da:
            continue
        fix = da.get("actionable_fix")
        if fix and fix not in seen:
            seen.add(fix)
            fixes.append(f"[{node['id']}] {fix}")
    return fixes


# ---------------------------------------------------------------------------
# Narrative rendering
# ---------------------------------------------------------------------------

def _fmt_campaign_outcome(dag: Dict[str, Any]) -> str:
    """Format the campaign outcome section."""
    summary = dag.get("summary", {})
    campaign_info = dag.get("campaign", {})
    lines = []
    artifact_dir = campaign_info.get("artifact_dir", "unknown")
    lines.append(f"- **Artifact directory**: `{artifact_dir}`")
    lines.append(f"- **Total nodes**: {summary.get('total_nodes', '?')}")
    lines.append(f"- **Total edges**: {summary.get('total_edges', '?')}")
    lines.append(f"- **Critical path length**: {len(summary.get('critical_path', []))}")
    lines.append(f"- **Trajectory-changing decisions**: {len(summary.get('trajectory_changing_decisions', []))}")
    lines.append(f"- **Actionable fixes**: {len(summary.get('actionable_fixes', []))}")
    return "\n".join(lines)


def _fmt_critical_path(cp: List[str], nodes: List[Dict[str, Any]]) -> str:
    """Format the critical path as a numbered list."""
    if not cp:
        return "_No critical path computed._"
    node_map = {n["id"]: n for n in nodes}
    lines = []
    for i, nid in enumerate(cp, 1):
        node = node_map.get(nid, {})
        role = node.get("agent_role", "")
        stage_labels = node.get("stage_labels", [])
        stage = stage_labels[0] if stage_labels else ""
        oi = None
        metrics = node.get("metrics") or {}
        oi = metrics.get("output_influence")
        oi_str = f", influence={oi:.2f}" if oi is not None else ""
        lines.append(f"{i}. **{nid}** — role: {role or 'unknown'}, stage: {stage or 'unknown'}{oi_str}")
    return "\n".join(lines)


def _fmt_trajectory_decisions(decisions: List[Dict[str, Any]]) -> str:
    """Format trajectory-changing decisions."""
    if not decisions:
        return "_No trajectory-changing decisions detected._"
    lines = []
    for d in decisions:
        anomaly_str = ", ".join(d["anomaly_types"])
        lines.append(f"- **{d['node_id']}**: anomalies=[{anomaly_str}], outgoing_edges={d['outgoing_count']}")
    return "\n".join(lines)


def _fmt_anomalies(nodes: List[Dict[str, Any]]) -> str:
    """Format anomaly details for all nodes that have anomalies."""
    anomalous = [n for n in nodes if n.get("anomaly")]
    if not anomalous:
        return "_No anomalies detected._"

    sections = []
    for node in anomalous:
        nid = node["id"]
        anomaly_types = node.get("anomaly", [])
        da = node.get("deep_analysis")
        metrics = node.get("metrics") or {}

        lines = [f"### {nid}"]
        lines.append(f"- **Anomaly types**: {', '.join(anomaly_types)}")

        # Relevant metrics
        relevant = {k: v for k, v in metrics.items() if v is not None}
        if relevant:
            metric_str = ", ".join(f"{k}={v:.3f}" if isinstance(v, float) else f"{k}={v}" for k, v in relevant.items())
            lines.append(f"- **Metrics**: {metric_str}")

        if da:
            if da.get("root_cause"):
                lines.append(f"- **Root cause**: {da['root_cause']}")
            causal_chain = da.get("causal_chain", [])
            if causal_chain:
                lines.append(f"- **Causal chain**: {' → '.join(causal_chain)}")
            if da.get("counterfactual"):
                lines.append(f"- **Counterfactual**: {da['counterfactual']}")
            if da.get("actionable_fix"):
                lines.append(f"- **Fix**: {da['actionable_fix']}")
            if da.get("confidence") is not None:
                lines.append(f"- **Confidence**: {da['confidence'] * 100:.0f}%")

        sections.append("\n".join(lines))

    return "\n\n".join(sections)


def _fmt_recommendations(fixes: List[str]) -> str:
    """Format actionable fixes as a list."""
    if not fixes:
        return "_No actionable fixes identified. Provide deep_analysis to populate this section._"
    lines = [f"- {fix}" for fix in fixes]
    return "\n".join(lines)


def _fmt_cross_version_delta(dag: Dict[str, Any]) -> str:
    """Format cross-version comparison (placeholder if not provided)."""
    delta = dag.get("summary", {}).get("cross_version_delta")
    if not delta:
        return "_No previous version data available for comparison._"
    lines = []
    for k, v in delta.items():
        lines.append(f"- **{k}**: {v}")
    return "\n".join(lines)


def _render_narrative(dag: Dict[str, Any], nodes: List[Dict[str, Any]]) -> str:
    """Render the narrative Markdown by filling in template placeholders."""
    template = _read_template("narrative_template.md")

    summary = dag.get("summary", {})
    cp = summary.get("critical_path", [])
    traj = summary.get("trajectory_changing_decisions", [])
    fixes = summary.get("actionable_fixes", [])

    replacements = {
        "{{campaign_outcome}}": _fmt_campaign_outcome(dag),
        "{{critical_path}}": _fmt_critical_path(cp, nodes),
        "{{trajectory_decisions}}": _fmt_trajectory_decisions(traj),
        "{{anomalies}}": _fmt_anomalies(nodes),
        "{{recommendations}}": _fmt_recommendations(fixes),
        "{{cross_version_delta}}": _fmt_cross_version_delta(dag),
    }

    result = template
    for placeholder, value in replacements.items():
        result = result.replace(placeholder, value)
    return result


# ---------------------------------------------------------------------------
# Viz rendering
# ---------------------------------------------------------------------------

def _render_viz(dag: Dict[str, Any]) -> str:
    """Render the interactive HTML visualization."""
    template = _read_template("viz_template.html")
    dag_json = json.dumps(dag, indent=None, default=str)
    return template.replace("__DAG_JSON_PLACEHOLDER__", dag_json)


# ---------------------------------------------------------------------------
# Public API
# ---------------------------------------------------------------------------

def generate_postmortem(
    scored_dag: Dict[str, Any],
    events: List[Dict[str, Any]],
    deep_analysis: Optional[List[Dict[str, Any]]],
) -> Dict[str, Any]:
    """Generate a complete causal post-mortem from a scored DAG.

    Args:
        scored_dag: Scored DAG dict from score_nodes.score_nodes().
        events: Event list from extract_events.extract_events().
        deep_analysis: Optional list of deep analysis dicts, each with keys:
            node_id, anomaly_type, root_cause, causal_chain, counterfactual,
            skill_attribution, actionable_fix, confidence.

    Returns:
        Dict with keys:
            "dag":       Enriched DAG dict with summary fields populated.
            "narrative": Markdown post-mortem string.
            "viz_html":  Interactive HTML visualization string.
    """
    dag = deepcopy(scored_dag)
    nodes = dag["nodes"]
    edges = dag["edges"]

    # 1. Merge deep analysis into nodes
    _merge_deep_analysis(nodes, deep_analysis)

    # 2. Compute critical path
    critical_path = _compute_critical_path(nodes, edges)

    # 3. Find trajectory-changing decisions
    trajectory_decisions = _find_trajectory_decisions(nodes, edges)

    # 4. Collect actionable fixes from deep analysis
    actionable_fixes = _collect_fixes(nodes)

    # 5. Populate summary fields
    summary = dag.setdefault("summary", {})
    summary["critical_path"] = critical_path
    summary["trajectory_changing_decisions"] = trajectory_decisions
    summary["actionable_fixes"] = actionable_fixes

    # 6. Render outputs
    narrative = _render_narrative(dag, nodes)
    viz_html = _render_viz(dag)

    return {
        "dag": dag,
        "narrative": narrative,
        "viz_html": viz_html,
    }


# ---------------------------------------------------------------------------
# CLI
# ---------------------------------------------------------------------------

def main() -> int:
    p = argparse.ArgumentParser(
        description=__doc__,
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )
    p.add_argument("--scored-dag", required=True, help="Path to scored_dag.json (from score_nodes.py)")
    p.add_argument("--events", required=True, help="Path to events.json (from extract_events.py)")
    p.add_argument("--output-dag", required=True, help="Output path for final enriched dag.json")
    p.add_argument("--output-narrative", required=True, help="Output path for postmortem.md")
    p.add_argument("--output-viz", required=True, help="Output path for viz.html")
    p.add_argument(
        "--deep-analysis",
        default=None,
        help="Optional path to deep_analysis.json (from causal_analyzer agent)",
    )

    args = p.parse_args()

    # Validate inputs
    for path_str, label in [(args.scored_dag, "scored-dag"), (args.events, "events")]:
        if not Path(path_str).exists():
            print(f"ERROR: {label} file not found: {path_str}", file=sys.stderr)
            return 1

    try:
        scored_dag = json.loads(Path(args.scored_dag).read_text(encoding="utf-8"))
        events = json.loads(Path(args.events).read_text(encoding="utf-8"))
    except (json.JSONDecodeError, OSError) as e:
        print(f"ERROR reading input files: {e}", file=sys.stderr)
        return 1

    deep_analysis = None
    if args.deep_analysis:
        da_path = Path(args.deep_analysis)
        if not da_path.exists():
            print(f"ERROR: deep-analysis file not found: {da_path}", file=sys.stderr)
            return 1
        try:
            deep_analysis = json.loads(da_path.read_text(encoding="utf-8"))
        except (json.JSONDecodeError, OSError) as e:
            print(f"ERROR reading deep-analysis: {e}", file=sys.stderr)
            return 1

    result = generate_postmortem(
        scored_dag=scored_dag,
        events=events,
        deep_analysis=deep_analysis,
    )

    # Write outputs
    Path(args.output_dag).write_text(
        json.dumps(result["dag"], indent=2, default=str) + "\n", encoding="utf-8"
    )
    print(f"Wrote enriched DAG to: {args.output_dag}", file=sys.stderr)

    Path(args.output_narrative).write_text(result["narrative"], encoding="utf-8")
    print(f"Wrote narrative to: {args.output_narrative}", file=sys.stderr)

    Path(args.output_viz).write_text(result["viz_html"], encoding="utf-8")
    print(f"Wrote viz to: {args.output_viz}", file=sys.stderr)

    return 0


if __name__ == "__main__":
    sys.exit(main())
slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack."Stars: 198kUpdated Claude CodeCodexVerifiedInstall
ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt.Stars: 194kUpdated Claude CodeCodexVerifiedInstall