Add ExecutionContext module and missing determinism test suite

[Copilot]

The pr28-determinism.yml CI workflow calls python tests/test_determinism.py which did not exist, causing every PR run to fail. The problem statement specifies a full deterministic execution pipeline built around an ExecutionContext class.

New files

• execution_context.py — Core implementation:

  • ExecutionContext — state container (seed, manifest, commands, repo_state, audit_log)
  • canonicalize() — normalizes CRLF→LF, strips trailing whitespace, sorts JSON keys; returns UTF-8 bytes
  • merkle_root() — binary Merkle tree over canonicalized file contents (odd-node duplication)
  • execute_command() — MODE_1_EXECUTE mutates repo_state; MODE_2_SIMULATE is a no-op; both append an audit record
  • integrity_loop() — up to MAX_REPAIR_ATTEMPTS=3 canonicalization passes before enter_mode_0_halt()
  • test_determinism() — runs the command sequence 5× and asserts all Merkle roots agree

• tests/test_determinism.py — 13 standalone tests (D_001–D_011), runnable via python tests/test_determinism.py (matching the pattern of the existing test_falsification.py):

D_001  canonicalize is idempotent
D_002  sha256 of fixed bytes matches NIST reference
D_003  merkle_root({}) == sha256(b'')
D_004  merkle_root single-file matches sha256(canonicalize(content))
D_005  merkle_root two-file result is stable across calls
D_006  MODE_1_EXECUTE mutates repo_state; MODE_2_SIMULATE does not
D_007  execute_command always appends exactly one audit-log entry
D_008  test_determinism() returns True for a fixed command sequence
D_009  verify_invariants True/False based on manifest match
D_010  integrity_loop repairs CRLF content and returns True
D_011  integrity_loop returns False (MODE_0_HALT) on irrecoverable mismatch

Original prompt

chatgpt: import os
import json
import hashlib
import uuid
from copy import deepcopy
from collections import deque

--- Execution Context ---

class ExecutionContext:
def init(self, seed: str, manifest: dict, commands: list):
self.seed = seed
self.manifest = manifest
self.commands = commands
self.repo_state = {}
self.current_hash = None
self.audit_log = []

--- Canonicalization ---

def canonicalize(content: str) -> str:
content = content.replace('\r\n', '\n').replace('\r', '\n')
content = '\n'.join(line.rstrip() for line in content.split('\n'))
try:
data = json.loads(content)
content = json.dumps(sort_json_keys(data), separators=(',', ':'))
except json.JSONDecodeError:
pass
return content.encode('utf-8')

def sort_json_keys(obj):
if isinstance(obj, dict):
return {k: sort_json_keys(obj[k]) for k in sorted(obj.keys())}
elif isinstance(obj, list):
return [sort_json_keys(e) for e in obj]
else:
return obj

--- Hashing ---

def sha256(data: bytes) -> str:
return hashlib.sha256(data).hexdigest()

def merkle_root(files: dict) -> str:
leaves = [sha256(canonicalize(content)) for content in files.values()]
while len(leaves) > 1:
next_level = []
for i in range(0, len(leaves), 2):
left = leaves[i]
right = leaves[i+1] if i+1 < len(leaves) else left
next_level.append(sha256((left+right).encode()))
leaves = next_level
return leaves[0] if leaves else sha256(b'')

--- Audit Logging ---

def log_operation(ctx: ExecutionContext, command: dict, mode: str, output_hash: str):
ctx.audit_log.append({
"operation_id": str(uuid.uuid4()),
"mode": mode,
"command": command,
"output_hash": output_hash,
"metadata": {}
})

--- Modes ---

def execute_command(ctx: ExecutionContext, command: dict, mode: str):
if mode == "MODE_2_SIMULATE":
pass
elif mode == "MODE_1_EXECUTE":
ctx.repo_state[command['file']] = command['content']
output_hash = merkle_root(ctx.repo_state)
log_operation(ctx, command, mode, output_hash)

--- Verification & Repair ---

MAX_REPAIR_ATTEMPTS = 3

def verify_invariants(ctx: ExecutionContext) -> bool:
return merkle_root(ctx.repo_state) == ctx.manifest['root_hash']

def canonicalize_repo(ctx: ExecutionContext):
new_state = {}
for k, v in ctx.repo_state.items():
new_state[k] = canonicalize(v).decode('utf-8')
ctx.repo_state = new_state
return ctx.repo_state

def integrity_loop(ctx: ExecutionContext):
attempts = 0
while attempts < MAX_REPAIR_ATTEMPTS:
if verify_invariants(ctx):
return True
else:
canonicalize_repo(ctx)
attempts += 1
return enter_mode_0_halt(ctx)

def enter_mode_0_halt(ctx: ExecutionContext):
return False

--- Test Harness ---

def test_determinism(seed: str, manifest: dict, commands: list):
results = []
for _ in range(5):
ctx = ExecutionContext(seed, manifest, deepcopy(commands))
for cmd in commands:
execute_command(ctx, cmd, "MODE_1_EXECUTE")
results.append(merkle_root(ctx.repo_state))
return len(set(results)) == 1

--- Example Usage ---

if name == "main":
manifest = {"root_hash": sha256(b"")}
commands = [{"file": "a.txt", "content": "Hello"}]
ctx = ExecutionContext("seed123", manifest, commands)
for cmd in commands:
execute_command(ctx, cmd, "MODE_1_EXECUTE")
integrity_loop(ctx)

HALTING

---

✨ Let Copilot coding agent set things up for you — coding agent works faster and does higher quality work when set up for your repo.

[devin-ai-integration]

Closing as stale (Stage D housekeeping).

This Copilot draft has been open without progress and is superseded by:

• PR PR #139: Universal Aerospace Floor + 35 Polymath Domains + Standards + Upgrades #139 (Universal Aerospace Floor + 35 polymath domains) — landed 2026-04-18
• PR Kimi/pr139 aerospace floor polymath domains #140 (Kimi aerospace-floor polymath follow-up) — landed 2026-04-19
• PR audit(stage-a): hashed investigative taxonomy + gap-analysis JSONL #141 (hashed investigative taxonomy) — landed 2026-04-19
• PR cleanup(stage-b): eliminate float() calls and stubs in production code #142 (production-code cleanup: float() / stubs) — landed 2026-04-19
• PR stage-c: enforce YAML frontmatter on all Markdown files #143 (Markdown frontmatter enforcement) — in review

If the underlying work here is still wanted, re-open a fresh PR rebased on current main; the old branches have substantial drift and CI has moved on. Closing now so the open-PR list reflects reality.