codex-flow 2.1.13__py3-none-any.whl

codex_flow/data/benchmark/corpus.json

@@ -0,0 +1,103 @@
+{
+  "schema_version": 2,
+  "tasks": [
+    {
+      "id": "routine-query-normalization",
+      "class": "routine",
+      "description": "Localized bug fix with edge-case normalization and no API change.",
+      "prompt": "Fix search.normalize_query so leading/trailing whitespace is removed, internal whitespace runs collapse to one space, and Unicode text is preserved. Keep the public function name/signature unchanged. Add or update tests only if useful; do not modify anything outside the repository.",
+      "files": {
+        "search.py": "import re\n\ndef normalize_query(value: str) -> str:\n    # BUG: strips only ASCII spaces and does not collapse runs.\n    return value.strip(' ')\n",
+        "README.md": "# Query normalization\n\n`normalize_query` prepares user-entered search text while preserving Unicode content.\n"
+      },
+      "verifier": "from pathlib import Path\nimport importlib.util\nroot=Path.cwd()\nspec=importlib.util.spec_from_file_location('search', root/'search.py')\nm=importlib.util.module_from_spec(spec); spec.loader.exec_module(m)\ncases={\n '  hello   world  ':'hello world',\n '\\t hello\\nworld \\r':'hello world',\n '  \u5fae\u4fe1   \u8bed\u97f3  ':'\u5fae\u4fe1 \u8bed\u97f3',\n '':'',\n '   ':'',\n}\nfor raw,want in cases.items():\n    got=m.normalize_query(raw)\n    assert got==want,(raw,got,want)\nassert m.normalize_query.__name__=='normalize_query'\n"
+    },
+    {
+      "id": "routine-env-precedence",
+      "class": "routine",
+      "description": "Configuration precedence bug requiring exact fallback semantics.",
+      "prompt": "Fix config.resolve_endpoint. Explicit argument must win when non-empty; otherwise use SERVICE_ENDPOINT from the supplied env mapping when non-empty; otherwise return DEFAULT_ENDPOINT. Treat whitespace-only values as empty. Do not read os.environ implicitly and keep the existing public signature.",
+      "files": {
+        "config.py": "DEFAULT_ENDPOINT = 'https://api.example.test'\n\ndef resolve_endpoint(explicit, env):\n    # BUG: env always wins and whitespace values leak through.\n    return env.get('SERVICE_ENDPOINT') or explicit or DEFAULT_ENDPOINT\n"
+      },
+      "verifier": "from pathlib import Path\nimport importlib.util\nspec=importlib.util.spec_from_file_location('config',Path.cwd()/'config.py')\nm=importlib.util.module_from_spec(spec); spec.loader.exec_module(m)\nassert m.resolve_endpoint('https://explicit', {'SERVICE_ENDPOINT':'https://env'})=='https://explicit'\nassert m.resolve_endpoint(None, {'SERVICE_ENDPOINT':'https://env'})=='https://env'\nassert m.resolve_endpoint('', {'SERVICE_ENDPOINT':'https://env'})=='https://env'\nassert m.resolve_endpoint('   ', {'SERVICE_ENDPOINT':'  '})==m.DEFAULT_ENDPOINT\nassert m.resolve_endpoint(None, {})==m.DEFAULT_ENDPOINT\n"
+    },
+    {
+      "id": "routine-header-sanitization",
+      "class": "routine",
+      "description": "HTTP header sanitization, case normalization, and injection protection.",
+      "prompt": "Fix headers.sanitize_headers(headers: dict). Header names must be lowercase stripped strings containing only valid RFC 7230 token characters (alphanumerics and !#$%&'*+-.^_`|~); reject invalid or empty names with ValueError. Header values must be stripped strings; reject any value containing CR (\\r) or LF (\\n) with ValueError; convert integer and float values to strings; and drop headers whose sanitized value is empty. Return a new dict with sanitized headers. Do not modify the input dict.",
+      "files": {
+        "headers.py": "def sanitize_headers(headers):\n    # BUG: does not lower-case names, allows invalid tokens/CRLF injection, mutates input\n    return {k: str(v) for k, v in headers.items()}\n"
+      },
+      "verifier": "from pathlib import Path\nimport importlib.util\nspec = importlib.util.spec_from_file_location('headers', Path.cwd() / 'headers.py')\nm = importlib.util.module_from_spec(spec)\nspec.loader.exec_module(m)\norig = {' Content-Type ': ' text/plain ', 'X-Rate-Limit': 100, 'X-Score': 3.14}\nout = m.sanitize_headers(orig)\nassert out == {'content-type': 'text/plain', 'x-rate-limit': '100', 'x-score': '3.14'}\nassert orig[' Content-Type '] == ' text/plain '\nassert m.sanitize_headers({'X-Empty': '', 'X-Space': '   ', 'Keep': 'val'}) == {'keep': 'val'}\nfor bad_name in ('', '   ', 'Bad Name', 'Header:Colon', 'Foo@Bar', 'Invalid/Slash'):\n    try:\n        m.sanitize_headers({bad_name: 'val'})\n    except ValueError:\n        pass\n    else:\n        raise AssertionError(f'invalid header name accepted: {bad_name!r}')\nfor bad_val in ('evil\\r\\nInjected: true', 'foo\\nbar', 'bar\\rbaz'):\n    try:\n        m.sanitize_headers({'x-safe': bad_val})\n    except ValueError:\n        pass\n    else:\n        raise AssertionError(f'CRLF injection accepted: {bad_val!r}')\n"
+    },
+    {
+      "id": "complex-renew-provider-refactor",
+      "class": "complex",
+      "description": "Multi-file registry refactor with isolation, validation, normalization, and legacy compatibility.",
+      "prompt": "Refactor the renewal package around a reusable ProviderRegistry without breaking the existing renew(name) API. ProviderRegistry.register(name, handler, *, replace=False) must trim and case-fold non-empty provider names, reject non-callables, reject duplicates unless replace=True, and keep registry instances isolated. ProviderRegistry.dispatch(provider, name) must use the same normalization, raise a clear ValueError containing the requested provider when unknown, and propagate handler exceptions unchanged. Keep a module-level registry in renew.service seeded with the legacy handler. Expose register_provider and renew_for through both renew.service and renew.__init__; renew(name) and consumer.run() must retain legacy behavior. Avoid hidden registration side effects outside the explicit module-level legacy seed.",
+      "files": {
+        "renew/__init__.py": "from .service import renew\n\n__all__ = ['renew']\n",
+        "renew/registry.py": "class ProviderRegistry:\n    def __init__(self):\n        self._handlers = {}\n\n    def register(self, name, handler):\n        self._handlers[name] = handler\n\n    def dispatch(self, provider, name):\n        return self._handlers[provider](name)\n",
+        "renew/service.py": "from .legacy import renew_legacy\n\ndef renew(name):\n    return renew_legacy(name)\n",
+        "renew/legacy.py": "def renew_legacy(name):\n    return {'provider':'legacy','name':name,'status':'renewed'}\n",
+        "consumer.py": "from renew import renew\n\ndef run():\n    return renew('demo')\n"
+      },
+      "verifier": "from pathlib import Path\nimport sys\nsys.path.insert(0,str(Path.cwd()))\nimport renew\nfrom renew import service\nfrom renew.registry import ProviderRegistry\nassert renew.renew('a')=={'provider':'legacy','name':'a','status':'renewed'}\nassert renew.renew_for is service.renew_for and renew.register_provider is service.register_provider\nassert {'renew','renew_for','register_provider'} <= set(renew.__all__)\none=ProviderRegistry(); two=ProviderRegistry(); seen=[]\ndef handler(name): seen.append(name); return {'provider':'new','name':name}\none.register('  New  ',handler)\nassert one.dispatch('new','b')=={'provider':'new','name':'b'} and seen==['b']\ntry: two.dispatch('new','x')\nexcept ValueError: pass\nelse: raise AssertionError('registry instances leaked state')\ntry: one.register('NEW',handler)\nexcept ValueError: pass\nelse: raise AssertionError('canonical duplicate accepted')\none.register('new',lambda name:{'provider':'replacement','name':name},replace=True)\nassert one.dispatch(' NEW ','c')['provider']=='replacement'\nfor bad in ('', '   ', None):\n try: one.register(bad,handler)\n except (ValueError,TypeError): pass\n else: raise AssertionError(('bad name accepted',bad))\ntry: one.register('bad',object())\nexcept TypeError: pass\nelse: raise AssertionError('non-callable accepted')\ntry: one.dispatch(' missing-provider ','x')\nexcept ValueError as e: assert 'missing-provider' in str(e)\nelse: raise AssertionError('unknown provider must fail')\nclass Boom(Exception): pass\none.register('boom',lambda name: (_ for _ in ()).throw(Boom(name)))\ntry: one.dispatch('boom','x')\nexcept Boom as e: assert str(e)=='x'\nelse: raise AssertionError('handler exception changed')\nservice.register_provider(' API ',handler)\nassert service.renew_for('api','z')=={'provider':'new','name':'z'}\nfrom consumer import run\nassert run()=={'provider':'legacy','name':'demo','status':'renewed'}\n"
+    },
+    {
+      "id": "complex-config-migration",
+      "class": "complex",
+      "description": "Idempotent, alias-safe configuration migration with per-key precedence and validation.",
+      "prompt": "Update settings.load_config to migrate the legacy flat endpoint/token keys into service.endpoint/service.token while accepting the new nested schema. New nested values win per key when the key is present; a missing nested key falls back to its legacy counterpart. Remove the consumed legacy keys, preserve unrelated top-level keys and unrelated service keys, and keep genuinely missing endpoint/token keys absent. The result must be a deep independent copy: never mutate or alias the input, including nested lists/dicts. Applying load_config to its own output must be idempotent. raw and an existing service value must be mappings; reject invalid shapes with TypeError before returning a partial result.",
+      "files": {
+        "settings.py": "def load_config(raw):\n    # Current implementation only understands the legacy flat shape.\n    result = dict(raw)\n    service = {}\n    if 'endpoint' in result:\n        service['endpoint'] = result.pop('endpoint')\n    if 'token' in result:\n        service['token'] = result.pop('token')\n    result['service'] = service\n    return result\n"
+      },
+      "verifier": "from pathlib import Path\nfrom collections import UserDict\nimport importlib.util,copy\nspec=importlib.util.spec_from_file_location('settings',Path.cwd()/'settings.py')\nm=importlib.util.module_from_spec(spec); spec.loader.exec_module(m)\nlegacy={'endpoint':'e1','token':'t1','feature':{'flags':['a']}}; before=copy.deepcopy(legacy)\nout=m.load_config(legacy); assert legacy==before; assert out=={'service':{'endpoint':'e1','token':'t1'},'feature':{'flags':['a']}}\nout['feature']['flags'].append('b'); assert legacy==before\nnew={'service':{'endpoint':'e2','token':'t2','headers':{'x':['1']}},'feature':False}; before=copy.deepcopy(new)\nout=m.load_config(new); assert new==before and out==new and out is not new and out['service'] is not new['service']\nout['service']['headers']['x'].append('2'); assert new==before\nmixed={'endpoint':'old','token':'oldt','service':{'endpoint':None,'headers':{'a':1}},'x':1}\nout=m.load_config(mixed); assert out['service']=={'endpoint':None,'token':'oldt','headers':{'a':1}}; assert out['x']==1; assert 'endpoint' not in out and 'token' not in out\nempty=m.load_config({'x':1}); assert empty in ({'x':1},{'x':1,'service':{}}); assert 'endpoint' not in empty.get('service',{}) and 'token' not in empty.get('service',{})\nwrapped=UserDict({'endpoint':'e','service':{'token':'t'}}); assert m.load_config(wrapped)['service']=={'endpoint':'e','token':'t'}\nonce=m.load_config({'endpoint':'e','token':'t','nested':{'v':[1]}}); twice=m.load_config(once); assert twice==once and twice is not once and twice['nested'] is not once['nested']\nfor bad in (None,[],42):\n try: m.load_config(bad)\n except TypeError: pass\n else: raise AssertionError(('invalid raw accepted',bad))\nfor bad_service in (None,[],42,'x'):\n try: m.load_config({'service':bad_service,'endpoint':'e'})\n except TypeError: pass\n else: raise AssertionError(('invalid service accepted',bad_service))\n"
+    },
+    {
+      "id": "complex-dag-resolver",
+      "class": "complex",
+      "description": "Topological dependency graph resolver with cycle detection, tie-breaking, and batch scheduling.",
+      "prompt": "Implement a multi-stage dependency graph scheduler in the scheduler package. scheduler.graph.DependencyGraph allows adding nodes with dependencies via add_node(name, dependencies=None) where dependencies is an optional iterable of string node names; names and dependencies must be stripped non-empty strings. scheduler.resolver.resolve_order(graph) returns a deterministic topologically sorted list of node names; when multiple nodes are ready, tie-break by lexicographical order; raise scheduler.errors.CycleDetectedError (which stores the cycle path list in exc.cycle) if a dependency cycle exists, and raise scheduler.errors.MissingDependencyError (storing exc.missing_node) if a dependency is not registered in the graph. scheduler.resolver.resolve_batches(graph) returns list[list[str]] grouping independent nodes that can execute concurrently in each stage, with each stage's node list sorted lexicographically. Expose DependencyGraph, resolve_order, resolve_batches, CycleDetectedError, and MissingDependencyError in scheduler.__init__.",
+      "files": {
+        "scheduler/__init__.py": "from .graph import DependencyGraph\nfrom .resolver import resolve_order, resolve_batches\nfrom .errors import CycleDetectedError, MissingDependencyError\n\n__all__ = [\n    'DependencyGraph', 'resolve_order', 'resolve_batches',\n    'CycleDetectedError', 'MissingDependencyError',\n]\n",
+        "scheduler/errors.py": "class CycleDetectedError(ValueError):\n    def __init__(self, cycle=None):\n        super().__init__(f'Cycle detected: {cycle}')\n        self.cycle = list(cycle) if cycle else []\n\nclass MissingDependencyError(KeyError):\n    def __init__(self, missing_node=None):\n        super().__init__(f'Missing dependency: {missing_node}')\n        self.missing_node = missing_node\n",
+        "scheduler/graph.py": "class DependencyGraph:\n    def __init__(self):\n        self.nodes = {}\n\n    def add_node(self, name, dependencies=None):\n        # BUG: does not strip/validate names and stores dependencies as-is\n        self.nodes[name] = list(dependencies or [])\n",
+        "scheduler/resolver.py": "# BUG: naive incomplete resolver without tie-breaking, cycle path detection, or batching\ndef resolve_order(graph):\n    return list(graph.nodes.keys())\n\ndef resolve_batches(graph):\n    return [[k] for k in graph.nodes.keys()]\n"
+      },
+      "verifier": "from pathlib import Path\nimport sys\nsys.path.insert(0, str(Path.cwd()))\nimport scheduler\nfrom scheduler import DependencyGraph, resolve_order, resolve_batches, CycleDetectedError, MissingDependencyError\nassert {'DependencyGraph', 'resolve_order', 'resolve_batches', 'CycleDetectedError', 'MissingDependencyError'} <= set(scheduler.__all__)\ng = DependencyGraph()\ng.add_node('c', ['a', 'b']); g.add_node('b'); g.add_node('a'); g.add_node('d', ['c'])\nassert resolve_order(g) == ['a', 'b', 'c', 'd']\nassert resolve_batches(g) == [['a', 'b'], ['c'], ['d']]\ng2 = DependencyGraph()\nfor name in ('delta', 'beta', 'alpha', 'gamma'): g2.add_node(name)\nassert resolve_order(g2) == ['alpha', 'beta', 'delta', 'gamma']\nassert resolve_batches(g2) == [['alpha', 'beta', 'delta', 'gamma']]\ng3 = DependencyGraph(); g3.add_node('task1', ['ghost'])\ntry:\n    resolve_order(g3)\nexcept MissingDependencyError as exc:\n    assert exc.missing_node == 'ghost'\nelse:\n    raise AssertionError('missing dependency error not raised')\ng4 = DependencyGraph()\ng4.add_node('p1', ['p2']); g4.add_node('p2', ['p3']); g4.add_node('p3', ['p1'])\ntry:\n    resolve_order(g4)\nexcept CycleDetectedError as exc:\n    assert len(exc.cycle) >= 2\nelse:\n    raise AssertionError('cycle detected error not raised')\nfor bad in ('', '   ', None):\n    try: DependencyGraph().add_node(bad)\n    except (ValueError, TypeError): pass\n    else: raise AssertionError(f'bad node name accepted: {bad!r}')\n"
+    },
+    {
+      "id": "critical-resumable-migration",
+      "class": "critical",
+      "description": "Crash-resumable record migration with preflight validation and durable progress tracking.",
+      "prompt": "Implement migration.run_migration(store, journal_path). The store exposes list_ids(), read(record_id), and write_atomic(record_id, value). Preflight every record before writing anything: each record must be a mapping with schema 1 or 2; schema-1 records require a non-empty string name, while schema-2 records require profile.name. Convert schema 1 to schema 2 by moving name to profile.name, preserving enabled and unrelated fields, and never mutating objects returned by the store. Process record ids in deterministic sorted order. After each successful write, atomically persist a JSON journal {'completed':[...]} beside journal_path using a flushed/fsynced temporary file and os.replace. On restart, a valid journal may skip an id only when the current record is already schema 2; stale completed entries whose record is still schema 1 must be processed. A failed write must not be journaled. Remove the journal after all records are safely migrated. Malformed records or journals must raise ValueError before any write. The migration must be idempotent.",
+      "files": {
+        "migration.py": "def run_migration(store, journal_path):\n    # BUG: neither validates nor journals progress and mutates source values.\n    for record_id in store.list_ids():\n        value = store.read(record_id)\n        if value.get('schema') == 1:\n            value['schema'] = 2\n            value['profile'] = {'name': value.pop('name')}\n            store.write_atomic(record_id, value)\n"
+      },
+      "verifier": "from pathlib import Path\nimport copy,importlib.util,json,tempfile\nspec=importlib.util.spec_from_file_location('migration',Path.cwd()/'migration.py')\nm=importlib.util.module_from_spec(spec); spec.loader.exec_module(m)\nclass Store:\n def __init__(self,data,fail=None): self.data=copy.deepcopy(data); self.fail=fail; self.writes=[]; self.read_values=[]\n def list_ids(self): return list(reversed(list(self.data)))\n def read(self,k):\n  value=copy.deepcopy(self.data[k]); self.read_values.append(value); return value\n def write_atomic(self,k,v):\n  if self.fail==k: raise OSError('crash')\n  self.writes.append(k); self.data[k]=copy.deepcopy(v)\nwith tempfile.TemporaryDirectory() as td:\n journal=Path(td)/'progress.json'; original={'b':{'schema':1,'name':'Bee','enabled':False,'x':1},'a':{'schema':2,'profile':{'name':'Ay'},'enabled':True}}\n store=Store(original); m.run_migration(store,journal)\n assert store.writes==['b']; assert store.data['b']=={'schema':2,'profile':{'name':'Bee'},'enabled':False,'x':1}; assert not journal.exists(); assert original['b']['schema']==1\n before=copy.deepcopy(store.data); m.run_migration(store,journal); assert store.data==before and store.writes==['b']\nwith tempfile.TemporaryDirectory() as td:\n journal=Path(td)/'progress.json'; store=Store({'b':{'schema':1,'name':'B'},'a':{'schema':1,'name':'A'}},fail='b')\n try: m.run_migration(store,journal)\n except OSError: pass\n else: raise AssertionError('write failure must propagate')\n assert store.writes==['a']; assert json.loads(journal.read_text())=={'completed':['a']}\n store.fail=None; m.run_migration(store,journal); assert store.writes==['a','b']; assert all(v['schema']==2 for v in store.data.values()); assert not journal.exists()\nwith tempfile.TemporaryDirectory() as td:\n journal=Path(td)/'progress.json'; journal.write_text('{\"completed\":[\"a\"]}')\n store=Store({'a':{'schema':1,'name':'A'}}); m.run_migration(store,journal); assert store.writes==['a'] and not journal.exists()\nfor bad in ({'a':{'schema':1,'name':''}},{'a':{'schema':2,'profile':{}}},{'a':{'schema':9,'name':'x'}},{'a':[],'b':{'schema':1,'name':'B'}}):\n with tempfile.TemporaryDirectory() as td:\n  store=Store(bad); journal=Path(td)/'j.json'\n  try: m.run_migration(store,journal)\n  except ValueError: pass\n  else: raise AssertionError(('invalid data accepted',bad))\n  assert store.writes==[]\nwith tempfile.TemporaryDirectory() as td:\n journal=Path(td)/'j.json'; journal.write_text('{bad'); store=Store({'a':{'schema':1,'name':'A'}})\n try: m.run_migration(store,journal)\n except ValueError: pass\n else: raise AssertionError('malformed journal accepted')\n assert store.writes==[]\n"
+    },
+    {
+      "id": "critical-atomic-state-write",
+      "class": "critical",
+      "description": "Crash-durable atomic replacement with permission preservation, directory fsync, and failure cleanup.",
+      "prompt": "Harden state.save_json for crash-durable replacement. Serialize JSON to a uniquely named temporary file in the destination directory, flush and fsync the file, then atomically replace the destination with os.replace and fsync the parent directory after replacement. Preserve the existing destination's permission bits; for a new destination use mode 0600. Serialization, write/fsync, or replace failures must clean up every temporary file. A failure before a successful os.replace must leave an existing destination byte-for-byte unchanged. Do not follow an existing destination symlink when choosing permissions. Keep load_json behavior and deterministic sort_keys output compatible.",
+      "files": {
+        "state.py": "import json\nfrom pathlib import Path\n\ndef load_json(path):\n    with open(path,'r',encoding='utf-8') as f:\n        return json.load(f)\n\ndef save_json(path, value):\n    # BUG: direct write can truncate valid state on failure/crash.\n    with open(path,'w',encoding='utf-8') as f:\n        json.dump(value,f,sort_keys=True)\n"
+      },
+      "verifier": "from pathlib import Path\nimport importlib.util,tempfile,os,stat,unittest.mock as mock\nspec=importlib.util.spec_from_file_location('state',Path.cwd()/'state.py')\nm=importlib.util.module_from_spec(spec); spec.loader.exec_module(m)\nwith tempfile.TemporaryDirectory() as td:\n p=Path(td)/'state.json'; p.write_text('{\"old\":1}',encoding='utf-8'); os.chmod(p,0o640)\n real_replace=os.replace; real_fsync=os.fsync; events=[]\n def wrapped_replace(src,dst): events.append(('replace',Path(src),Path(dst))); return real_replace(src,dst)\n def wrapped_fsync(fd): events.append(('fsync',stat.S_ISDIR(os.fstat(fd).st_mode))); return real_fsync(fd)\n with mock.patch.object(os,'replace',wrapped_replace),mock.patch.object(os,'fsync',wrapped_fsync): m.save_json(p,{'z':2,'a':1})\n assert p.read_text(encoding='utf-8')=='{\"a\": 1, \"z\": 2}' and stat.S_IMODE(os.stat(p).st_mode)==0o640\n replace_index=next(i for i,e in enumerate(events) if e[0]=='replace'); assert any(e==('fsync',False) for e in events[:replace_index]); assert any(e==('fsync',True) for e in events[replace_index+1:])\n assert events[replace_index][1].parent==p.parent and events[replace_index][2]==p; assert not [x for x in p.parent.iterdir() if x!=p]\nwith tempfile.TemporaryDirectory() as td:\n p=Path(td)/'new.json'; m.save_json(p,{'x':1}); assert stat.S_IMODE(os.stat(p).st_mode)==0o600 and m.load_json(p)=={'x':1}\nwith tempfile.TemporaryDirectory() as td:\n p=Path(td)/'state.json'; p.write_text('{\"old\":1}',encoding='utf-8')\n def fail_replace(src,dst): raise OSError('replace failed')\n with mock.patch.object(os,'replace',fail_replace):\n  try: m.save_json(p,{'new':2})\n  except OSError: pass\n  else: raise AssertionError('replace failure swallowed')\n assert p.read_text(encoding='utf-8')=='{\"old\":1}' and not [x for x in p.parent.iterdir() if x!=p]\nwith tempfile.TemporaryDirectory() as td:\n p=Path(td)/'state.json'; p.write_text('{\"old\":1}',encoding='utf-8')\n class Bad: pass\n try: m.save_json(p,{'bad':Bad()})\n except (TypeError,ValueError): pass\n else: raise AssertionError('serialization should fail')\n assert p.read_text(encoding='utf-8')=='{\"old\":1}' and not [x for x in p.parent.iterdir() if x!=p]\nwith tempfile.TemporaryDirectory() as td:\n target=Path(td)/'target'; target.write_text('secret'); os.chmod(target,0o777); link=Path(td)/'state.json'; link.symlink_to(target)\n m.save_json(link,{'safe':True}); assert not link.is_symlink(); assert target.read_text()=='secret'; assert stat.S_IMODE(os.stat(link).st_mode)==0o600\n"
+    },
+    {
+      "id": "critical-audit-event-wal",
+      "class": "critical",
+      "description": "Crash-durable Write-Ahead Log with record framing, CRC32 integrity, and torn-write recovery.",
+      "prompt": "Implement AuditWAL in audit_wal.py for crash-durable event logging. AuditWAL(path) creates or opens an append-only log file. append(event: dict) -> int validates event is a JSON mapping, serializes it to UTF-8, frames it with a 12-byte binary header: 4-byte magic b'WAL1', 4-byte big-endian uint32 payload length, and 4-byte big-endian uint32 CRC32 checksum of the payload bytes (using zlib.crc32). It writes the frame, flushes and fsyncs the file descriptor, and returns the 0-based entry sequence number. recover() -> list[dict] reads all valid events from the start. If the file ends with a torn/partial write (truncated header or incomplete payload at EOF), recover() must salvage all prior valid records, truncate the file back to the end of the last intact record using truncate() and fsync(), and return the valid records. If a corrupted header, bad magic bytes, or CRC32 mismatch occurs with valid data remaining after it (a non-terminal corruption), recover() must raise IntegrityError without truncating. Reopening an intact log preserves previously appended records and sequence numbers.",
+      "files": {
+        "audit_wal.py": "import json\n\nclass IntegrityError(Exception):\n    pass\n\nclass AuditWAL:\n    def __init__(self, path):\n        self.path = path\n        self._count = 0\n\n    def append(self, event):\n        # BUG: simple non-atomic JSON lines, no magic, no CRC32, no fsync\n        with open(self.path, 'a') as f:\n            f.write(json.dumps(event) + '\\n')\n        seq = self._count\n        self._count += 1\n        return seq\n\n    def recover(self):\n        # BUG: fails to handle framing, CRC32 or torn writes\n        records = []\n        try:\n            with open(self.path, 'r') as f:\n                for line in f:\n                    records.append(json.loads(line))\n        except FileNotFoundError:\n            pass\n        return records\n"
+      },
+      "verifier": "from pathlib import Path\nimport importlib.util, tempfile, os, struct, zlib\nspec = importlib.util.spec_from_file_location('audit_wal', Path.cwd() / 'audit_wal.py')\nm = importlib.util.module_from_spec(spec)\nspec.loader.exec_module(m)\nwith tempfile.TemporaryDirectory() as td:\n    log_path = Path(td) / 'audit.wal'\n    wal = m.AuditWAL(log_path)\n    seq0 = wal.append({'action': 'login', 'user': 'alice'})\n    seq1 = wal.append({'action': 'update', 'user': 'bob'})\n    assert seq0 == 0 and seq1 == 1\n    raw = log_path.read_bytes()\n    assert raw.startswith(b'WAL1')\n    magic, length, crc = struct.unpack('>4sII', raw[:12])\n    assert magic == b'WAL1'\n    payload = raw[12:12+length]\n    assert (zlib.crc32(payload) & 0xffffffff) == crc\n    recovered = wal.recover()\n    assert len(recovered) == 2\n    assert recovered[0]['user'] == 'alice' and recovered[1]['user'] == 'bob'\n    wal.append({'action': 'delete', 'user': 'charlie'})\n    before_len = log_path.stat().st_size\n    log_path.write_bytes(log_path.read_bytes()[:-5])\n    salvaged = wal.recover()\n    assert len(salvaged) == 2\n    assert log_path.stat().st_size < before_len\n    seq2 = wal.append({'action': 'logout', 'user': 'alice'})\n    assert seq2 == 2\n    final_recs = wal.recover()\n    assert len(final_recs) == 3 and final_recs[-1]['action'] == 'logout'\nwith tempfile.TemporaryDirectory() as td:\n    log_path = Path(td) / 'audit2.wal'\n    wal = m.AuditWAL(log_path)\n    wal.append({'n': 1})\n    wal.append({'n': 2})\n    raw = bytearray(log_path.read_bytes())\n    raw[15] ^= 0xFF\n    log_path.write_bytes(bytes(raw))\n    try:\n        wal.recover()\n    except m.IntegrityError:\n        pass\n    else:\n        raise AssertionError('mid-log corruption must raise IntegrityError')\n"
+    }
+  ]
+}

codex_flow/data/benchmark/manifest.example.json

@@ -0,0 +1,41 @@
+{
+  "schema_version": 2,
+  "repetitions": 3,
+  "timeout_seconds": 1800,
+  "max_repair_cycles": 2,
+  "matrix": [
+    {"id": "luna-direct", "strategy": "direct", "model": "gpt-5.6-luna", "reasoning_effort": "high"},
+    {"id": "terra-direct", "strategy": "direct", "model": "gpt-5.6-terra", "reasoning_effort": "high"},
+    {"id": "sol-direct", "strategy": "direct", "model": "gpt-5.6-sol", "reasoning_effort": "high"},
+    {
+      "id": "codex-flow-high",
+      "strategy": "flow",
+      "reasoning_policy": "fixed",
+      "parent": {"model": "gpt-5.6-sol", "reasoning_effort": "high"},
+      "worker": {"model": "gpt-5.6-luna", "reasoning_effort": "high"}
+    },
+    {
+      "id": "codex-flow-adaptive",
+      "strategy": "flow",
+      "reasoning_policy": "adaptive",
+      "parent": {
+        "model": "gpt-5.6-sol",
+        "reasoning_effort": {"routine": "high", "complex": "xhigh", "critical": "max"}
+      },
+      "worker": {
+        "model": "gpt-5.6-luna",
+        "reasoning_effort": {"routine": "high", "complex": "xhigh", "critical": "max"}
+      }
+    }
+  ],
+  "tasks": [
+    {
+      "id": "example-compatibility-refactor",
+      "class": "complex",
+      "source": "/absolute/path/to/frozen-benchmark-repo",
+      "base_ref": "0123456789abcdef0123456789abcdef01234567",
+      "prompt": "Implement the requested change without weakening acceptance criteria.",
+      "verify": ["python3", "/absolute/path/to/external-verifier.py"]
+    }
+  ]
+}

codex_flow/data/benchmark/manifest.schema.json

@@ -0,0 +1,137 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "codex-flow benchmark runner manifest",
+  "type": "object",
+  "required": ["schema_version", "tasks", "matrix"],
+  "properties": {
+    "schema_version": {"const": 2},
+    "repetitions": {"type": "integer", "minimum": 1, "default": 1},
+    "timeout_seconds": {"type": "integer", "minimum": 1, "default": 1800},
+    "max_repair_cycles": {"type": "integer", "minimum": 0, "default": 2},
+    "allow_floating_refs": {"type": "boolean", "default": false},
+    "matrix": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "oneOf": [
+          {
+            "type": "object",
+            "required": ["id", "strategy", "model", "reasoning_effort"],
+            "properties": {
+              "id": {"type": "string", "minLength": 1},
+              "strategy": {"const": "direct"},
+              "model": {"type": "string", "minLength": 1},
+              "reasoning_effort": {"enum": ["high", "xhigh", "max"]}
+            },
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "required": ["id", "strategy", "reasoning_policy", "parent", "worker"],
+            "properties": {
+              "id": {"type": "string", "minLength": 1},
+              "strategy": {"enum": ["flow", "runtime"]},
+              "reasoning_policy": {"enum": ["fixed", "adaptive"]},
+              "parent": {"$ref": "#/$defs/actor"},
+              "worker": {"$ref": "#/$defs/actor"},
+              "profile": {"type": "string"},
+              "routing_mode": {"type": "string"}
+            },
+            "allOf": [
+              {
+                "if": {"properties": {"reasoning_policy": {"const": "fixed"}}},
+                "then": {
+                  "properties": {
+                    "parent": {"$ref": "#/$defs/fixed_actor"},
+                    "worker": {"$ref": "#/$defs/fixed_actor"}
+                  }
+                }
+              },
+              {
+                "if": {"properties": {"reasoning_policy": {"const": "adaptive"}}},
+                "then": {
+                  "properties": {
+                    "parent": {"$ref": "#/$defs/adaptive_actor"},
+                    "worker": {"$ref": "#/$defs/adaptive_actor"}
+                  }
+                }
+              }
+            ],
+            "additionalProperties": false
+          }
+        ]
+      }
+    },
+    "tasks": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": ["id", "class", "source", "base_ref", "prompt", "verify"],
+        "properties": {
+          "id": {"type": "string", "minLength": 1},
+          "class": {"enum": ["routine", "complex", "critical"]},
+          "source": {"type": "string", "minLength": 1},
+          "base_ref": {"type": "string", "minLength": 1},
+          "prompt": {"type": "string", "minLength": 1},
+          "verify": {"type": "array", "minItems": 1, "items": {"type": "string"}},
+          "max_repair_cycles": {"type": "integer", "minimum": 0}
+        },
+        "additionalProperties": false
+      }
+    }
+  },
+  "$defs": {
+    "actor": {
+      "type": "object",
+      "required": ["model", "reasoning_effort"],
+      "properties": {
+        "model": {"type": "string", "minLength": 1},
+        "reasoning_effort": {
+          "oneOf": [
+            {"enum": ["high", "xhigh", "max"]},
+            {
+              "type": "object",
+              "required": ["routine", "complex", "critical"],
+              "properties": {
+                "routine": {"enum": ["high", "xhigh", "max"]},
+                "complex": {"enum": ["high", "xhigh", "max"]},
+                "critical": {"enum": ["high", "xhigh", "max"]}
+              },
+              "additionalProperties": false
+            }
+          ]
+        }
+      },
+      "additionalProperties": false
+    },
+    "fixed_actor": {
+      "type": "object",
+      "required": ["model", "reasoning_effort"],
+      "properties": {
+        "model": {"type": "string", "minLength": 1},
+        "reasoning_effort": {"enum": ["high", "xhigh", "max"]}
+      },
+      "additionalProperties": false
+    },
+    "adaptive_actor": {
+      "type": "object",
+      "required": ["model", "reasoning_effort"],
+      "properties": {
+        "model": {"type": "string", "minLength": 1},
+        "reasoning_effort": {
+          "type": "object",
+          "required": ["routine", "complex", "critical"],
+          "properties": {
+            "routine": {"enum": ["high", "xhigh", "max"]},
+            "complex": {"enum": ["high", "xhigh", "max"]},
+            "critical": {"enum": ["high", "xhigh", "max"]}
+          },
+          "additionalProperties": false
+        }
+      },
+      "additionalProperties": false
+    }
+  },
+  "additionalProperties": false
+}

codex_flow/data/benchmark/prices/gpt-5.6-2026-08-30.json

@@ -0,0 +1,5 @@
+{
+  "gpt-5.6-luna": {"input": 0.20, "cached_input": 0.02, "output": 1.20},
+  "gpt-5.6-terra": {"input": 2.00, "cached_input": 0.20, "output": 12.00},
+  "gpt-5.6-sol": {"input": 4.00, "cached_input": 0.40, "output": 20.00}
+}

codex_flow/data/benchmark/profiles.json

@@ -0,0 +1,90 @@
+{
+  "schema_version": 2,
+  "profiles": {
+    "quick": {
+      "description": "One repetition across three high direct models, fixed-high flow, and adaptive-effort flow.",
+      "repetitions": 1,
+      "matrix": [
+        {"id": "luna-direct", "strategy": "direct", "model": "gpt-5.6-luna", "reasoning_effort": "high"},
+        {"id": "terra-direct", "strategy": "direct", "model": "gpt-5.6-terra", "reasoning_effort": "high"},
+        {"id": "sol-direct", "strategy": "direct", "model": "gpt-5.6-sol", "reasoning_effort": "high"},
+        {
+          "id": "codex-flow-high",
+          "strategy": "flow",
+          "reasoning_policy": "fixed",
+          "parent": {"model": "gpt-5.6-sol", "reasoning_effort": "high"},
+          "worker": {"model": "gpt-5.6-luna", "reasoning_effort": "high"}
+        },
+        {
+          "id": "codex-flow-adaptive",
+          "strategy": "flow",
+          "reasoning_policy": "adaptive",
+          "parent": {
+            "model": "gpt-5.6-sol",
+            "reasoning_effort": {"routine": "high", "complex": "xhigh", "critical": "max"}
+          },
+          "worker": {
+            "model": "gpt-5.6-luna",
+            "reasoning_effort": {"routine": "high", "complex": "xhigh", "critical": "max"}
+          }
+        }
+      ]
+    },
+    "full": {
+      "description": "Three repetitions across three high direct models, fixed-high flow, and adaptive-effort flow.",
+      "repetitions": 3,
+      "matrix": [
+        {"id": "luna-direct", "strategy": "direct", "model": "gpt-5.6-luna", "reasoning_effort": "high"},
+        {"id": "terra-direct", "strategy": "direct", "model": "gpt-5.6-terra", "reasoning_effort": "high"},
+        {"id": "sol-direct", "strategy": "direct", "model": "gpt-5.6-sol", "reasoning_effort": "high"},
+        {
+          "id": "codex-flow-high",
+          "strategy": "flow",
+          "reasoning_policy": "fixed",
+          "parent": {"model": "gpt-5.6-sol", "reasoning_effort": "high"},
+          "worker": {"model": "gpt-5.6-luna", "reasoning_effort": "high"}
+        },
+        {
+          "id": "codex-flow-adaptive",
+          "strategy": "flow",
+          "reasoning_policy": "adaptive",
+          "parent": {
+            "model": "gpt-5.6-sol",
+            "reasoning_effort": {"routine": "high", "complex": "xhigh", "critical": "max"}
+          },
+          "worker": {
+            "model": "gpt-5.6-luna",
+            "reasoning_effort": {"routine": "high", "complex": "xhigh", "critical": "max"}
+          }
+        }
+      ]
+    },
+    "agentic": {
+      "description": "One repetition comparing direct baselines with real FlowPilot runtime execution under efficient and balanced profiles.",
+      "repetitions": 1,
+      "matrix": [
+        {"id": "luna-direct", "strategy": "direct", "model": "gpt-5.6-luna", "reasoning_effort": "high"},
+        {"id": "terra-direct", "strategy": "direct", "model": "gpt-5.6-terra", "reasoning_effort": "high"},
+        {"id": "sol-direct", "strategy": "direct", "model": "gpt-5.6-sol", "reasoning_effort": "high"},
+        {
+          "id": "codex-flow-runtime-efficient",
+          "strategy": "runtime",
+          "reasoning_policy": "fixed",
+          "profile": "efficient",
+          "routing_mode": "delegate",
+          "parent": {"model": "gpt-5.6-sol", "reasoning_effort": "high"},
+          "worker": {"model": "gpt-5.6-luna", "reasoning_effort": "high"}
+        },
+        {
+          "id": "codex-flow-runtime-balanced",
+          "strategy": "runtime",
+          "reasoning_policy": "fixed",
+          "profile": "balanced",
+          "routing_mode": "delegate",
+          "parent": {"model": "gpt-5.6-sol", "reasoning_effort": "high"},
+          "worker": {"model": "gpt-5.6-luna", "reasoning_effort": "high"}
+        }
+      ]
+    }
+  }
+}

codex_flow/data/benchmark/schema.json

@@ -0,0 +1,77 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "codex-flow benchmark strategy run",
+  "type": "object",
+  "required": [
+    "schema_version", "task_id", "task_class", "strategy_id", "strategy",
+    "reasoning_policy", "model", "reasoning_effort", "worker_model", "worker_reasoning_effort",
+    "passed", "first_passed", "input_tokens", "cached_input_tokens",
+    "output_tokens", "model_usage", "repair_cycles", "review_cycles"
+  ],
+  "properties": {
+    "schema_version": {"const": 2},
+    "task_id": {"type": "string", "minLength": 1},
+    "task_class": {"enum": ["routine", "complex", "critical"]},
+    "strategy_id": {"type": "string", "minLength": 1},
+    "strategy": {"enum": ["direct", "flow", "runtime"]},
+    "reasoning_policy": {"enum": ["fixed", "adaptive"]},
+    "model": {"type": "string", "minLength": 1},
+    "reasoning_effort": {"enum": ["high", "xhigh", "max"]},
+    "worker_model": {"type": ["string", "null"]},
+    "worker_reasoning_effort": {"type": ["string", "null"], "enum": ["high", "xhigh", "max", null]},
+    "passed": {"type": "boolean"},
+    "first_passed": {"type": "boolean"},
+    "input_tokens": {"type": "integer", "minimum": 0},
+    "cached_input_tokens": {"type": "integer", "minimum": 0},
+    "output_tokens": {"type": "integer", "minimum": 0},
+    "model_usage": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": ["role", "model", "reasoning_effort", "calls", "input_tokens", "cached_input_tokens", "output_tokens"],
+        "properties": {
+          "role": {"enum": ["direct", "parent", "worker"]},
+          "model": {"type": "string", "minLength": 1},
+          "reasoning_effort": {"enum": ["high", "xhigh", "max"]},
+          "calls": {"type": "integer", "minimum": 1},
+          "input_tokens": {"type": "integer", "minimum": 0},
+          "cached_input_tokens": {"type": "integer", "minimum": 0},
+          "output_tokens": {"type": "integer", "minimum": 0}
+        },
+        "additionalProperties": false
+      }
+    },
+    "repair_cycles": {"type": "integer", "minimum": 0},
+    "review_cycles": {"type": "integer", "minimum": 0},
+    "wall_time_seconds": {"type": "number", "minimum": 0},
+    "source_commit": {"type": "string", "minLength": 1},
+    "repetition": {"type": "integer", "minimum": 1},
+    "codex_exit_code": {"type": "integer"},
+    "verification_excerpt": {"type": "string"},
+    "diagnostic_excerpt": {"type": "string"},
+    "notes": {"type": "string"}
+  },
+  "allOf": [
+    {
+      "if": {"properties": {"strategy": {"const": "direct"}}},
+      "then": {
+        "properties": {
+          "reasoning_policy": {"const": "fixed"},
+          "worker_model": {"type": "null"},
+          "worker_reasoning_effort": {"type": "null"}
+        }
+      }
+    },
+    {
+      "if": {"properties": {"strategy": {"enum": ["flow", "runtime"]}}},
+      "then": {
+        "properties": {
+          "worker_model": {"type": "string", "minLength": 1},
+          "worker_reasoning_effort": {"enum": ["high", "xhigh", "max"]}
+        }
+      }
+    }
+  ],
+  "additionalProperties": false
+}

codex_flow/data/benchmark/tasks.json

@@ -0,0 +1,50 @@
+{
+  "schema_version": 2,
+  "tasks": [
+    {
+      "id": "routine-query-normalization",
+      "class": "routine",
+      "description": "Localized bug fix with edge-case normalization and no API change."
+    },
+    {
+      "id": "routine-env-precedence",
+      "class": "routine",
+      "description": "Configuration precedence bug requiring exact fallback semantics."
+    },
+    {
+      "id": "routine-header-sanitization",
+      "class": "routine",
+      "description": "HTTP header sanitization, case normalization, and injection protection."
+    },
+    {
+      "id": "complex-renew-provider-refactor",
+      "class": "complex",
+      "description": "Multi-file registry refactor with isolation, validation, normalization, and legacy compatibility."
+    },
+    {
+      "id": "complex-config-migration",
+      "class": "complex",
+      "description": "Idempotent, alias-safe configuration migration with per-key precedence and validation."
+    },
+    {
+      "id": "complex-dag-resolver",
+      "class": "complex",
+      "description": "Topological dependency graph resolver with cycle detection, tie-breaking, and batch scheduling."
+    },
+    {
+      "id": "critical-resumable-migration",
+      "class": "critical",
+      "description": "Crash-resumable record migration with preflight validation and durable progress tracking."
+    },
+    {
+      "id": "critical-atomic-state-write",
+      "class": "critical",
+      "description": "Crash-durable atomic replacement with permission preservation, directory fsync, and failure cleanup."
+    },
+    {
+      "id": "critical-audit-event-wal",
+      "class": "critical",
+      "description": "Crash-durable Write-Ahead Log with record framing, CRC32 integrity, and torn-write recovery."
+    }
+  ]
+}

codex_flow/data/completions/codex-flow.bash

@@ -0,0 +1,34 @@
+# bash completion for codex-flow
+_codex_flow_completion() {
+    local cur="${COMP_WORDS[COMP_CWORD]}"
+    local commands="status strategy language update doctor overlay usage telemetry benchmark-local benchmark-corpus benchmark benchmark-analyze uninstall help"
+    if [[ "${COMP_CWORD}" -eq 1 ]]; then
+        COMPREPLY=( $(compgen -W "$commands" -- "$cur") )
+    elif [[ "${COMP_CWORD}" -eq 2 && "${COMP_WORDS[1]}" == "strategy" ]]; then
+        COMPREPLY=( $(compgen -W "show profiles enabled enable disable set routing plan" -- "$cur") )
+    elif [[ "${COMP_CWORD}" -eq 3 && "${COMP_WORDS[1]}" == "strategy" && "${COMP_WORDS[2]}" == "set" ]]; then
+        COMPREPLY=( $(compgen -W "efficient balanced quality speed" -- "$cur") )
+    elif [[ "${COMP_CWORD}" -eq 3 && "${COMP_WORDS[1]}" == "strategy" && "${COMP_WORDS[2]}" == "routing" ]]; then
+        COMPREPLY=( $(compgen -W "adaptive direct delegate" -- "$cur") )
+    elif [[ "${COMP_CWORD}" -ge 3 && "${COMP_WORDS[1]}" == "strategy" && "${COMP_WORDS[2]}" == "plan" ]]; then
+        COMPREPLY=( $(compgen -W "--profile --routing --review --fanout --complexity --uncertainty --risk --scope --parallelism --write-conflict --exploration-need --verification-cost --iteration-intensity --writable-workstreams --quality-intent --quota-pressure --max-threads --max-repairs" -- "$cur") )
+    elif [[ "${COMP_CWORD}" -eq 2 && "${COMP_WORDS[1]}" == "language" ]]; then
+        COMPREPLY=( $(compgen -W "auto zh en" -- "$cur") )
+    elif [[ "${COMP_CWORD}" -eq 2 && ( "${COMP_WORDS[1]}" == "benchmark-local" || "${COMP_WORDS[1]}" == "benchmark-corpus" ) ]]; then
+        COMPREPLY=( $(compgen -W "quick full" -- "$cur") )
+    elif [[ "${COMP_CWORD}" -eq 2 && ( "${COMP_WORDS[1]}" == "usage" || "${COMP_WORDS[1]}" == "telemetry" ) ]]; then
+        COMPREPLY=( $(compgen -W "last list show stats summary repair" -- "$cur") )
+    elif [[ "${COMP_WORDS[1]}" == "usage" || "${COMP_WORDS[1]}" == "telemetry" ]]; then
+        case "${COMP_WORDS[2]}" in
+            last) COMPREPLY=( $(compgen -W "--json" -- "$cur") ) ;;
+            list) COMPREPLY=( $(compgen -W "--json --today -n --limit -p --project" -- "$cur") ) ;;
+            show) COMPREPLY=( $(compgen -W "--json" -- "$cur") ) ;;
+            stats|summary) COMPREPLY=( $(compgen -W "--json -d --days -p --project" -- "$cur") ) ;;
+            repair) COMPREPLY=( $(compgen -W "--dry-run --json" -- "$cur") ) ;;
+            *) COMPREPLY=() ;;
+        esac
+    else
+        COMPREPLY=()
+    fi
+}
+complete -F _codex_flow_completion codex-flow