Jyotisha/docs/superpowers/plans/2026-06-30-technique-audit-strict-adjudication.md

Technique Audit Strict Adjudication Implementation Plan

For agentic workers: REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (- [ ]) syntax for tracking.

Goal: Make the existing Technique Audit Table a required compact gate inside strict adjudication for career, relationship, and finance.

Architecture: Reuse the current strict workflow contracts in mcp_server.py and the current prompt-pack audit table in scripts/jyotish_engine.py. Add one compact shared audit summary, then surface it through the existing engine/API/frontend layers without adding new compute-heavy logic.

Tech Stack: Python, existing strict workflow collectors, existing prompt-pack contract, pytest, existing frontend static contract tests.

Global Constraints

• Reuse current Technique Audit Table; do not create a second audit table system.
• Do not add new heavy computation or new external requests.
• Keep career, relationship, and finance route-specific gates intact.
• Preserve honesty boundaries: blocked, fallback_used, conflicts, and confidence_cap must remain explicit.
• Functional benefic/malefic must remain visible as a first-class high-rigor gate.

---

Task 1: Add compact technique audit summary to strict workflow contracts

Files:

• Modify: <repo>/mcp_server.py
• Test: <repo>/tests/test_mcp_strict_workflow_career.py
• Test: <repo>/tests/test_mcp_strict_workflow_relationship.py
• Test: <repo>/tests/test_mcp_strict_workflow_finance.py

Interfaces:

• Consumes:

  • strict["present_evidence"]
  • strict["official_primary_evidence"]
  • strict["local_supplemental_evidence"]
  • strict["fallback_used"]
  • strict["blocked_items"]
  • strict["conflicts"]

• Produces:

  • strict["technique_audit_summary"]
  • strict["multi_reference_reading_summary"]["audit_gate_frame"]

• Step 1: Write the failing tests

def test_career_strict_contract_exposes_compact_technique_audit_summary() -> None:
    strict = _collect_strict_evidence("career", _sample_result())
    audit = strict["technique_audit_summary"]
    assert audit["functional_benefic_malefic"]["gate"] == "hard"
    assert audit["relevant_vargas"]["gate"] == "hard"
    assert audit["vimshottari_narayana_crosscheck"]["gate"] == "hard"
    assert audit["source_priority_boundary"]["fallback_used"] == strict["fallback_used"]

def test_relationship_multi_reference_summary_carries_audit_gate_frame() -> None:
    strict = _collect_strict_evidence("relationship", _sample_result())
    frame = strict["multi_reference_reading_summary"]["audit_gate_frame"]
    assert frame["functional_benefic_malefic"]["used"] in {True, False}
    assert frame["source_priority_boundary"]["blocked_items"] == strict["blocked_items"]

def test_finance_strict_contract_compact_audit_marks_dual_dasha_gate() -> None:
    strict = _collect_strict_evidence("finance", {"modules": {"source_priority": {"mode": "local_fallback_official_blocked"}}})
    audit = strict["technique_audit_summary"]
    assert audit["vimshottari_narayana_crosscheck"]["gate"] == "hard"
    assert "official_primary_chart_blocked" in audit["source_priority_boundary"]["blocked_items"]

• Step 2: Run tests to verify they fail

Run:

python3 -m pytest tests/test_mcp_strict_workflow_career.py tests/test_mcp_strict_workflow_relationship.py tests/test_mcp_strict_workflow_finance.py -k "compact_technique_audit_summary or audit_gate_frame or dual_dasha_gate" -q

Expected: FAIL with missing technique_audit_summary or audit_gate_frame.

• Step 3: Write minimal implementation

Add compact builders in mcp_server.py:

def _route_varga_gate_keys(route: str) -> list[str]:
    if route == "career":
        return ["d10_dasamsa", "a10_karma_pada", "amatyakaraka", "karakamsha"]
    if route == "relationship":
        return ["d9_navamsa", "upapada_lagna", "darakaraka", "vivah_saham"]
    if route == "finance":
        return ["d2_hora", "d10_dasamsa", "shadbala", "ashtakavarga_house_scores"]
    return []

def _build_technique_audit_summary(route: str, strict: Dict[str, Any]) -> Dict[str, Any]:
    present = strict.get("present_evidence") or {}
    official = strict.get("official_primary_evidence") or {}
    local = strict.get("local_supplemental_evidence") or {}
    fallback_used = strict.get("fallback_used") or []
    blocked_items = strict.get("blocked_items") or []
    conflicts = strict.get("conflicts") or []
    return {
        "functional_benefic_malefic": {
            "gate": "hard",
            "used": bool((present.get("functional_benefic_malefic") or {}).get("status") == "used"),
            "note": (present.get("functional_benefic_malefic") or {}).get("effect_on_confidence"),
        },
        "relevant_vargas": {
            "gate": "hard",
            "required_keys": _route_varga_gate_keys(route),
            "present_keys": [key for key in _route_varga_gate_keys(route) if present.get(key)],
        },
        "vimshottari_narayana_crosscheck": {
            "gate": "hard",
            "used": bool(present.get("vimshottari_current")) and bool(present.get("narayana_current")),
            "required_timing_systems": ["Vimshottari", "Narayana"],
        },
        "source_priority_boundary": {
            "gate": "boundary",
            "official": official,
            "local": local,
            "fallback_used": fallback_used,
            "blocked_items": blocked_items,
            "conflicts": conflicts,
        },
    }

Attach it in _attach_top_reader_contract(...) and mirror it into multi_reference_reading_summary["audit_gate_frame"].

• Step 4: Run tests to verify they pass

Run:

python3 -m pytest tests/test_mcp_strict_workflow_career.py tests/test_mcp_strict_workflow_relationship.py tests/test_mcp_strict_workflow_finance.py -k "compact_technique_audit_summary or audit_gate_frame or dual_dasha_gate" -q

Expected: PASS

Task 2: Compact and expose the audit summary through full-reading and prompt pack

Files:

• Modify: <repo>/scripts/jyotish_engine.py
• Test: <repo>/tests/test_cli_smoke.py

Interfaces:

• Consumes:

  • modules[*_strict_evidence]

• Produces:

  • compact strict contracts that include technique_audit_summary

• Step 1: Write the failing test

def test_full_reading_prompt_pack_carries_compact_technique_audit_summary() -> None:
    result = run_engine(...)
    career = result["ai_prompt_pack"]["evidence_snapshot"]["strict_workflow_contracts"]["career"]
    assert "technique_audit_summary" in career
    assert career["technique_audit_summary"]["functional_benefic_malefic"]["gate"] == "hard"
    assert "audit_gate_frame" in career["multi_reference_reading_summary"]

• Step 2: Run test to verify it fails

Run:

python3 -m pytest tests/test_cli_smoke.py -k "compact_technique_audit_summary" -q

Expected: FAIL with missing technique_audit_summary.

• Step 3: Write minimal implementation

Extend _compact_strict_workflow_contract(...) in scripts/jyotish_engine.py:

"technique_audit_summary": strict.get("technique_audit_summary") or {},

Do not recompute anything new; just pass through the strict contract.

• Step 4: Run test to verify it passes

Run:

python3 -m pytest tests/test_cli_smoke.py -k "compact_technique_audit_summary" -q

Expected: PASS

Task 3: Surface the same compact audit summary in API outputs

Files:

• Modify: <repo>/scripts/jyotish_api_server.py
• Test: <repo>/tests/test_api_server_security.py

Interfaces:

• Consumes:

  • strict contract from prompt pack / official full snapshot

• Produces:

  • API outputs containing technique_audit_summary

• Step 1: Write the failing tests

def test_high_rigor_summary_passes_through_compact_technique_audit_summary() -> None:
    result = handler._high_rigor_vedastro_official_summary(chart)
    assert result["technique_audit_summary"]["functional_benefic_malefic"]["gate"] == "hard"

def test_consultation_workflow_surfaces_compact_technique_audit_summary(monkeypatch) -> None:
    result = handler._compute_consultation_workflow(payload)
    assert "technique_audit_summary" in result["vedastro_official"]

• Step 2: Run tests to verify they fail

Run:

python3 -m pytest tests/test_api_server_security.py -k "compact_technique_audit_summary" -q

Expected: FAIL with missing API passthrough key.

• Step 3: Write minimal implementation

In scripts/jyotish_api_server.py, add:

'technique_audit_summary': primary_contract.get('technique_audit_summary') or {},

to the shared official summary output path.

• Step 4: Run tests to verify they pass

Run:

python3 -m pytest tests/test_api_server_security.py -k "compact_technique_audit_summary" -q

Expected: PASS

Task 4: Make frontend and AI chat consume the compact audit summary

Files:

• Modify: <repo>/jyotish-app/main.js
• Modify: <repo>/jyotish-app/ai-chat.js
• Test: <repo>/tests/test_frontend_productization.py

Interfaces:

• Consumes:

  • compact strict contract

• Produces:

  • UI/AI references to technique_audit_summary

• Step 1: Write the failing test

def test_frontend_consumes_compact_technique_audit_summary_in_top_reader_contract() -> None:
    main = read("main.js")
    ai_chat = read("ai-chat.js")
    assert "technique_audit_summary" in main
    assert "technique_audit_summary" in ai_chat

• Step 2: Run test to verify it fails

Run:

python3 -m pytest tests/test_frontend_productization.py -k "compact_technique_audit_summary" -q

Expected: FAIL with missing frontend references.

• Step 3: Write minimal implementation

In main.js and ai-chat.js, read:

const techniqueAuditSummary = topReaderContract.technique_audit_summary || {};

and surface only a compact summary line, not the whole raw audit table.

• Step 4: Run test to verify it passes

Run:

python3 -m pytest tests/test_frontend_productization.py -k "compact_technique_audit_summary" -q

Expected: PASS

Task 5: Run focused regression and update progress

Files:

• Modify: <repo>/progress.md

Interfaces:

• Consumes:

  • all changes from Tasks 1-4

• Produces:

  • verification note in progress.md

• Step 1: Run focused regression

Run:

python3 -m pytest \
  tests/test_mcp_strict_workflow_career.py \
  tests/test_mcp_strict_workflow_relationship.py \
  tests/test_mcp_strict_workflow_finance.py \
  tests/test_cli_smoke.py \
  tests/test_api_server_security.py \
  tests/test_frontend_productization.py \
  -k "compact_technique_audit_summary or audit_gate_frame" -q

Expected: PASS

• Step 2: Update progress

Add an entry that the compact Technique Audit Table gate now sits inside default strict adjudication.

• Step 3: Run diff hygiene

Run:

git diff --check

Expected: no output

Self-Review

• Spec coverage: compact strict audit gate, prompt-pack passthrough, API passthrough, frontend consumption, and focused regression are all mapped to tasks.
• Placeholder scan: no TODO/TBD placeholders remain.
• Type consistency: technique_audit_summary and audit_gate_frame are used consistently across strict contract, prompt pack, API, and frontend.

Execution Handoff

Plan complete and saved to docs/superpowers/plans/2026-06-30-technique-audit-strict-adjudication.md. Two execution options:

1. Subagent-Driven (recommended) - I dispatch a fresh subagent per task, review between tasks, fast iteration

2. Inline Execution - Execute tasks in this session using executing-plans, batch execution with checkpoints

Which approach?