its-magic 0.1.3-3 → 0.1.3-4

package/template/scripts/autonomy_preset_lib.py

@@ -0,0 +1,224 @@
+#!/usr/bin/env python3
+"""
+Autonomy preset expansion library (US-0119).
+
+Expands AUTONOMY_PRESET into per-feature autonomy flags with deterministic,
+pure-stdlib logic. No LLM, no network, no .env reads.
+"""
+import sys
+import json
+from typing import Dict, Optional
+
+
+# 12 per-feature autonomy flags (DEC-0119 §7)
+AUTONOMY_FLAGS = {
+    "INTAKE_AUTONOMY_MODE",
+    "INTAKE_MINIMAL_PACK",
+    "INTAKE_ASSUME_STACK_CONTEXT",
+    "WORK_KIND_AUTO_ACCEPT",
+    "CROSS_MODEL_REWORK_EXHAUSTED_POLICY",
+    "CROSS_MODEL_SKIP_PHASES",
+    "RESUME_BRIEF_AUTO_REFRESH",
+    "RUNTIME_PROOF_KIND",
+    "GOAL_CONVERGENCE_INTERVAL",
+    "SOVEREIGN_DRAIN_AUTO_ACCEPT",
+    "RELEASE_PUBLISH_AUTO_CONFIRM",
+    "AUTONOMY_STOP_POLICY",
+}
+
+
+# Preset definitions (DEC-0119 §7)
+# none: empty expansion (byte-identical pre-US-0119)
+# balanced: 8 flags (moderate autonomy)
+# full: all 12 flags (maximum autonomy)
+PRESET_DEFINITIONS = {
+    "none": {},
+    "balanced": {
+        "WORK_KIND_AUTO_ACCEPT": "1",
+        "CROSS_MODEL_REWORK_EXHAUSTED_POLICY": "downgrade",
+        "CROSS_MODEL_SKIP_PHASES": "",
+        "RESUME_BRIEF_AUTO_REFRESH": "1",
+        "RUNTIME_PROOF_KIND": "lightweight",
+        "GOAL_CONVERGENCE_INTERVAL": "3",
+        "SOVEREIGN_DRAIN_AUTO_ACCEPT": "1",
+        "AUTONOMY_STOP_POLICY": "auto_repair_then_block",
+    },
+    "full": {
+        "INTAKE_AUTONOMY_MODE": "1",
+        "INTAKE_MINIMAL_PACK": "1",
+        "INTAKE_ASSUME_STACK_CONTEXT": "1",
+        "WORK_KIND_AUTO_ACCEPT": "1",
+        "CROSS_MODEL_REWORK_EXHAUSTED_POLICY": "downgrade",
+        "CROSS_MODEL_SKIP_PHASES": "",
+        "RESUME_BRIEF_AUTO_REFRESH": "1",
+        "RUNTIME_PROOF_KIND": "lightweight",
+        "GOAL_CONVERGENCE_INTERVAL": "1",
+        "SOVEREIGN_DRAIN_AUTO_ACCEPT": "1",
+        "RELEASE_PUBLISH_AUTO_CONFIRM": "1",
+        "AUTONOMY_STOP_POLICY": "auto_repair_then_skip",
+    },
+}
+
+
+def expand_autonomy_preset(
+    preset: str,
+    overrides: Optional[Dict[str, str]] = None
+) -> Dict[str, str]:
+    """
+    Expand AUTONOMY_PRESET into per-feature flags.
+
+    Args:
+        preset: One of {none, balanced, full}
+        overrides: Explicit per-flag values that override preset defaults
+
+    Returns:
+        Dict of flag_name -> flag_value
+
+    Raises:
+        ValueError: If preset is invalid or overrides contain unknown keys
+
+    Precedence (LOCKED): explicit per-flag > preset expansion > scratchpad defaults
+    """
+    if preset not in PRESET_DEFINITIONS:
+        raise ValueError(
+            f"Invalid AUTONOMY_PRESET='{preset}'. "
+            f"Must be one of: {', '.join(PRESET_DEFINITIONS.keys())}"
+        )
+
+    # Start with preset base
+    result = PRESET_DEFINITIONS[preset].copy()
+
+    # Apply overrides (explicit per-flag values always win)
+    if overrides:
+        unknown_keys = set(overrides.keys()) - AUTONOMY_FLAGS
+        if unknown_keys:
+            raise ValueError(
+                f"Unknown autonomy flag(s) in overrides: {', '.join(sorted(unknown_keys))}"
+            )
+        result.update(overrides)
+
+    return result
+
+
+def explain_preset(preset: str) -> Dict[str, Dict[str, str]]:
+    """
+    Explain preset expansion with source annotations.
+
+    Returns:
+        Dict of flag_name -> {value, source} where source is 'preset' or 'default'
+    """
+    expansion = PRESET_DEFINITIONS[preset]
+    result = {}
+
+    for flag in sorted(AUTONOMY_FLAGS):
+        if flag in expansion:
+            result[flag] = {
+                "value": expansion[flag],
+                "source": "preset"
+            }
+        else:
+            result[flag] = {
+                "value": "",
+                "source": "default"
+            }
+
+    return result
+
+
+def self_test() -> bool:
+    """
+    Self-test mode: verify known-key set, precedence, and preset expansions.
+
+    Returns:
+        True if all tests pass, False otherwise
+    """
+    tests_passed = 0
+    tests_total = 0
+
+    # Test 1: none preset is empty
+    tests_total += 1
+    result = expand_autonomy_preset("none")
+    if result == {}:
+        tests_passed += 1
+        print("[PASS] Test 1: none preset is empty")
+    else:
+        print(f"[FAIL] Test 1: expected {{}}, got {result}")
+
+    # Test 2: balanced preset has 8 flags
+    tests_total += 1
+    result = expand_autonomy_preset("balanced")
+    if len(result) == 8 and all(k in AUTONOMY_FLAGS for k in result.keys()):
+        tests_passed += 1
+        print("[PASS] Test 2: balanced preset has 8 flags, all known keys")
+    else:
+        print(f"[FAIL] Test 2: expected 8 flags, got {len(result)}")
+
+    # Test 3: full preset has 12 flags
+    tests_total += 1
+    result = expand_autonomy_preset("full")
+    if len(result) == 12 and all(k in AUTONOMY_FLAGS for k in result.keys()):
+        tests_passed += 1
+        print("[PASS] Test 3: full preset has 12 flags, all known keys")
+    else:
+        print(f"[FAIL] Test 3: expected 12 flags, got {len(result)}")
+
+    # Test 4: explicit override wins
+    tests_total += 1
+    result = expand_autonomy_preset("balanced", {"WORK_KIND_AUTO_ACCEPT": "0"})
+    if result.get("WORK_KIND_AUTO_ACCEPT") == "0":
+        tests_passed += 1
+        print("[PASS] Test 4: explicit override wins over preset")
+    else:
+        print(f"[FAIL] Test 4: expected '0', got '{result.get('WORK_KIND_AUTO_ACCEPT')}'")
+
+    # Test 5: unknown key in overrides raises ValueError
+    tests_total += 1
+    try:
+        expand_autonomy_preset("balanced", {"UNKNOWN_FLAG": "1"})
+        print("[FAIL] Test 5: should have raised ValueError for unknown key")
+    except ValueError:
+        tests_passed += 1
+        print("[PASS] Test 5: unknown key in overrides raises ValueError")
+
+    # Test 6: invalid preset raises ValueError
+    tests_total += 1
+    try:
+        expand_autonomy_preset("invalid")
+        print("[FAIL] Test 6: should have raised ValueError for invalid preset")
+    except ValueError:
+        tests_passed += 1
+        print("[PASS] Test 6: invalid preset raises ValueError")
+
+    print(f"\nSelf-test: {tests_passed}/{tests_total} tests passed")
+    return tests_passed == tests_total
+
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1:
+        mode = sys.argv[1]
+
+        if mode == "--self-test":
+            success = self_test()
+            sys.exit(0 if success else 1)
+
+        elif mode == "--explain":
+            if len(sys.argv) < 3:
+                print("Usage: autonomy_preset_lib.py --explain <preset>")
+                sys.exit(1)
+
+            preset = sys.argv[2]
+            try:
+                explanation = explain_preset(preset)
+                print(json.dumps(explanation, indent=2))
+            except Exception as e:
+                print(f"Error: {e}", file=sys.stderr)
+                sys.exit(1)
+
+        else:
+            print(f"Unknown mode: {mode}", file=sys.stderr)
+            print("Usage: autonomy_preset_lib.py [--self-test | --explain <preset>]", file=sys.stderr)
+            sys.exit(1)
+
+    else:
+        print("Autonomy Preset Library (US-0119)")
+        print("Usage: python autonomy_preset_lib.py [--self-test | --explain <preset>]")

package/template/scripts/check_intake_template_parity.py

@@ -16,6 +16,8 @@ Scoped modes (DEC-0073 §10 / US-0090):
   --scope=sovereign-parallel-dev DEC-0108 parallel instance arbitrage surfaces (US-0108).
   --scope=sovereign-self-healing-deploy DEC-0109 self-healing deploy loop surfaces (US-0109).
   --scope=release-trigger-adapter DEC-0111 release trigger adapter surfaces (US-0111).
+  --scope=us-0119               DEC-0119 autonomous-autonomy preset surfaces (US-0119).
+  --scope=us-0120               US-0120 dedicated /closure phase surfaces.
   --scope=all              union of all tables.
 """
 
@@ -409,6 +411,69 @@ RELEASE_TRIGGER_ADAPTER_PAIRS: tuple[tuple[str, str], ...] = (
     ),
 )
 
+# DEC-0118 §6 / US-0118 — Work-kind routing surface pairs. Contents must
+# be byte-identical between active and template paths; installer delivers
+# template copies (BUG-0003 / DEC-0066). 6 surface pairs per R-0106 Q6
+# LOCKED. Note: scratchpad key parity is structural (key presence) via
+# BUG-0013 test, NOT byte-parity (active scratchpad carries project-local
+# overrides like DELIVERY_MODE=ultra_lean that must not leak to template).
+WORK_KIND_ROUTING_PAIRS: tuple[tuple[str, str], ...] = (
+    (
+        "scripts/work_kind_classify_lib.py",
+        "template/scripts/work_kind_classify_lib.py",
+    ),
+    (
+        "scripts/work_kind_routing_lib.py",
+        "template/scripts/work_kind_routing_lib.py",
+    ),
+    (
+        "tests/us0118_contract_test.py",
+        "template/tests/us0118_contract_test.py",
+    ),
+    (".cursor/commands/auto.md", "template/.cursor/commands/auto.md"),
+    (".cursor/commands/intake.md", "template/.cursor/commands/intake.md"),
+    (
+        "docs/engineering/runbook.md",
+        "template/docs/engineering/runbook.md",
+    ),
+    (
+        "docs/engineering/context/installer-owned-paths.manifest",
+        "template/docs/engineering/context/installer-owned-paths.manifest",
+    ),
+    (
+        "scripts/check_intake_template_parity.py",
+        "template/scripts/check_intake_template_parity.py",
+    ),
+)
+
+# DEC-0119 §6 / US-0119 — Autonomous-autonomy preset surfaces. Contents must
+# be byte-identical between active and template paths. 8 surface pairs.
+AUTONOMY_PRESET_PAIRS: tuple[tuple[str, str], ...] = (
+    ("scripts/autonomy_preset_lib.py", "template/scripts/autonomy_preset_lib.py"),
+    ("scripts/validate_autonomy_stop_matrix.py", "template/scripts/validate_autonomy_stop_matrix.py"),
+    ("docs/engineering/autonomy-stop-matrix.md", "template/docs/engineering/autonomy-stop-matrix.md"),
+    ("docs/engineering/context/installer-owned-paths.manifest", "template/docs/engineering/context/installer-owned-paths.manifest"),
+    ("docs/engineering/runbook.md", "template/docs/engineering/runbook.md"),
+    (".cursor/commands/auto.md", "template/.cursor/commands/auto.md"),
+    ("tests/us0119_autonomy_preset_test.py", "template/tests/us0119_autonomy_preset_test.py"),
+)
+
+# US-0120 — Dedicated /closure phase surfaces. Contents must be byte-identical
+# between active and template paths.
+CLOSURE_PHASE_PAIRS: tuple[tuple[str, str], ...] = (
+    (".cursor/commands/closure.md", "template/.cursor/commands/closure.md"),
+    (".cursor/commands/release.md", "template/.cursor/commands/release.md"),
+    (".cursor/commands/auto.md", "template/.cursor/commands/auto.md"),
+    (
+        "scripts/validate_closure_verification.py",
+        "template/scripts/validate_closure_verification.py",
+    ),
+    (
+        "scripts/check_intake_template_parity.py",
+        "template/scripts/check_intake_template_parity.py",
+    ),
+)
+
 SCOPES: dict[str, tuple[tuple[str, str], ...]] = {
     "intake": INTAKE_TEMPLATE_PAIRS,
     "caveman-compress": CAVEMAN_COMPRESS_PAIRS,
@@ -428,6 +493,9 @@ SCOPES: dict[str, tuple[tuple[str, str], ...]] = {
     "sovereign-parallel-dev": SOVEREIGN_PARALLEL_DEV_PAIRS,
     "sovereign-self-healing-deploy": SOVEREIGN_SELF_HEALING_DEPLOY_PAIRS,
     "release-trigger-adapter": RELEASE_TRIGGER_ADAPTER_PAIRS,
+    "work-kind-routing": WORK_KIND_ROUTING_PAIRS,
+    "us-0119": AUTONOMY_PRESET_PAIRS,
+    "us-0120": CLOSURE_PHASE_PAIRS,
     "all": (
         INTAKE_TEMPLATE_PAIRS
         + CAVEMAN_COMPRESS_PAIRS
@@ -446,6 +514,9 @@ SCOPES: dict[str, tuple[tuple[str, str], ...]] = {
         + SOVEREIGN_ROLE_MANIFEST_PAIRS
         + SOVEREIGN_SELF_HEALING_DEPLOY_PAIRS
         + RELEASE_TRIGGER_ADAPTER_PAIRS
+        + WORK_KIND_ROUTING_PAIRS
+        + AUTONOMY_PRESET_PAIRS
+        + CLOSURE_PHASE_PAIRS
     ),
 }