id
stringlengths 12
12
| task_type
stringclasses 24
values | difficulty
stringclasses 3
values | primary_language
stringclasses 11
values | prompt
stringlengths 500
779
| response
stringlengths 1.49k
1.93k
| metadata
dict |
|---|---|---|---|---|---|---|
omega_000001
|
mechanized_spec
|
expert
|
lean
|
Task type: mechanized_spec
Scenario: time-series metrics store
Domain focus: compiler toolchains
Primary language: lean
Difficulty: expert
Scale/SLO: p99 < 50ms
Component: component_vouxqmpd
Constraints: include failure modes and recovery, assume adversarial inputs; validate everything, avoid data races and undefined behavior, include backward compatibility and migration plan, include test vectors and fuzz strategy, include security threat model (defensive only), include verification strategy
Assume partial data corruption; include scrubbing strategy.
Deliverable: Provide a mechanized-style spec outline (Lean-like), key definitions, and a proof plan. Include executable reference code skeleton and tests.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Liveness: under bounded faults and stable network, progress occurs.
- Safety: state transitions preserve invariants; no partial commit leaks.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
**Failure modes & recovery**
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Property tests against a pure reference model (state machine).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Deterministic simulation with fault injection (crash/partition/latency).
**Snippet**
```lean
-- Pseudo-Lean outline
structure State where
ver : Nat
val : Option ByteArray
def invariant (s : State) : Prop := True
theorem step_preserves_invariant :
∀ s, invariant s → ∀ s', Step s s' → invariant s' := by
intro s hs s' hstep
-- proof plan: case analysis on transition; trivial here
trivial
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"lean",
"formal-methods",
"theorem-proving"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000002
|
mechanized_spec
|
expert
|
lean
|
Task type: mechanized_spec
Scenario: rate limit gateway
Domain focus: runtime systems
Primary language: lean
Difficulty: expert
Scale/SLO: 99.99% availability
Component: component_frdiozsr
Constraints: assume adversarial inputs; validate everything, explicit contracts and invariants, include failure modes and recovery, avoid data races and undefined behavior, include deterministic replay plan
Assume schema changes every sprint; must be backward compatible.
Deliverable: Provide a mechanized-style spec outline (Lean-like), key definitions, and a proof plan. Include executable reference code skeleton and tests.
|
Output: elite engineering answer optimized for correctness, performance, and operability.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Liveness: under bounded faults and stable network, progress occurs.
- Safety: state transitions preserve invariants; no partial commit leaks.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Property tests against a pure reference model (state machine).
- Deterministic simulation with fault injection (crash/partition/latency).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
**Snippet**
```lean
-- Pseudo-Lean outline
structure State where
ver : Nat
val : Option ByteArray
def invariant (s : State) : Prop := True
theorem step_preserves_invariant :
∀ s, invariant s → ∀ s', Step s s' → invariant s' := by
intro s hs s' hstep
-- proof plan: case analysis on transition; trivial here
trivial
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"lean",
"formal-methods",
"theorem-proving"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000003
|
mechanized_spec
|
expert+
|
lean
|
Task type: mechanized_spec
Scenario: real-time notification hub
Domain focus: data lineage & governance
Primary language: lean
Difficulty: expert+
Scale/SLO: p99 < 50ms
Component: component_pcdkegbf
Constraints: avoid data races and undefined behavior, include performance model and limits, include test vectors and fuzz strategy, include backward compatibility and migration plan, include failure modes and recovery, include security threat model (defensive only), include verification strategy
Assume crash-only processes; recovery must be deterministic.
Deliverable: Provide a mechanized-style spec outline (Lean-like), key definitions, and a proof plan. Include executable reference code skeleton and tests.
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Determinism: replay of the same event log yields identical outputs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Safety: state transitions preserve invariants; no partial commit leaks.
**Failure modes & recovery**
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Network partition: minority cannot commit; clients receive retriable errors.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Deterministic simulation with fault injection (crash/partition/latency).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Property tests against a pure reference model (state machine).
**Snippet**
```lean
-- Pseudo-Lean outline
structure State where
ver : Nat
val : Option ByteArray
def invariant (s : State) : Prop := True
theorem step_preserves_invariant :
∀ s, invariant s → ∀ s', Step s s' → invariant s' := by
intro s hs s' hstep
-- proof plan: case analysis on transition; trivial here
trivial
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"lean",
"formal-methods",
"theorem-proving"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000004
|
mechanized_spec
|
expert+
|
lean
|
Task type: mechanized_spec
Scenario: multi-tenant event ingestion
Domain focus: constraint solving
Primary language: lean
Difficulty: expert+
Scale/SLO: 50 TB/day ingestion
Component: component_dgzxvxke
Constraints: explicit contracts and invariants, include failure modes and recovery, include performance model and limits, include backward compatibility and migration plan, include deterministic replay plan, avoid data races and undefined behavior
Assume hostile inputs and targeted abuse patterns.
Deliverable: Provide a mechanized-style spec outline (Lean-like), key definitions, and a proof plan. Include executable reference code skeleton and tests.
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Liveness: under bounded faults and stable network, progress occurs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Network partition: minority cannot commit; clients receive retriable errors.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Deterministic simulation with fault injection (crash/partition/latency).
- Property tests against a pure reference model (state machine).
**Snippet**
```lean
-- Pseudo-Lean outline
structure State where
ver : Nat
val : Option ByteArray
def invariant (s : State) : Prop := True
theorem step_preserves_invariant :
∀ s, invariant s → ∀ s', Step s s' → invariant s' := by
intro s hs s' hstep
-- proof plan: case analysis on transition; trivial here
trivial
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"lean",
"formal-methods",
"theorem-proving"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000005
|
mechanized_spec
|
expert+
|
lean
|
Task type: mechanized_spec
Scenario: multi-tenant event ingestion
Domain focus: high-frequency trading systems (safe engineering)
Primary language: lean
Difficulty: expert+
Scale/SLO: 100k RPS peak
Component: component_hjldkbhm
Constraints: avoid data races and undefined behavior, include security threat model (defensive only), explicit contracts and invariants, assume adversarial inputs; validate everything, include backward compatibility and migration plan
Assume tight memory budget and cold-start constraints.
Deliverable: Provide a mechanized-style spec outline (Lean-like), key definitions, and a proof plan. Include executable reference code skeleton and tests.
|
Output: elite engineering answer optimized for correctness, performance, and operability.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Safety: state transitions preserve invariants; no partial commit leaks.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Liveness: under bounded faults and stable network, progress occurs.
**Failure modes & recovery**
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Fuzzing of parsers/framers/validators with corpus seeds.
- Deterministic simulation with fault injection (crash/partition/latency).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
**Snippet**
```lean
-- Pseudo-Lean outline
structure State where
ver : Nat
val : Option ByteArray
def invariant (s : State) : Prop := True
theorem step_preserves_invariant :
∀ s, invariant s → ∀ s', Step s s' → invariant s' := by
intro s hs s' hstep
-- proof plan: case analysis on transition; trivial here
trivial
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"lean",
"formal-methods",
"theorem-proving"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000006
|
tla_state_machine
|
expert+
|
tla+
|
Task type: tla_state_machine
Scenario: multi-tenant event ingestion
Domain focus: runtime systems
Primary language: tla+
Difficulty: expert+
Scale/SLO: 50 TB/day ingestion
Component: component_ggtbnahf
Constraints: assume adversarial inputs; validate everything, explicit contracts and invariants, include test vectors and fuzz strategy, avoid data races and undefined behavior, include verification strategy, include deterministic replay plan
Assume partial data corruption; include scrubbing strategy.
Deliverable: Provide a TLA+-style state machine (pseudo), safety/liveness properties, and a model-checking strategy. Include an implementation sketch and test vectors.
|
Output: elite engineering answer optimized for correctness, performance, and operability.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Determinism: replay of the same event log yields identical outputs.
- Liveness: under bounded faults and stable network, progress occurs.
- Safety: state transitions preserve invariants; no partial commit leaks.
**Failure modes & recovery**
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Fuzzing of parsers/framers/validators with corpus seeds.
- Deterministic simulation with fault injection (crash/partition/latency).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
**Snippet**
```tla
VARIABLES state, log, seen
Init == state = [k \in Keys |-> <<0, NULL>>] /\ log = << >> /\ seen = [r \in ReqIds |-> NULL]
Put(req, k, v) ==
IF seen[req] # NULL THEN UNCHANGED <<state, log, seen>>
ELSE
LET ver == state[k][1] + 1 IN
/\ state' = [state EXCEPT ![k] = <<ver, v>>]
/\ log' = Append(log, <<req, k, v, ver>>)
/\ seen' = [seen EXCEPT ![req] = <<"ok", ver>>]
Safety == \A k \in Keys: state[k][1] >= 0
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"tla+",
"model-checking",
"state-machines"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000007
|
tla_state_machine
|
expert
|
tla+
|
Task type: tla_state_machine
Scenario: document indexing pipeline
Domain focus: formal verification
Primary language: tla+
Difficulty: expert
Scale/SLO: 10k RPS peak
Component: component_lvggtrbg
Constraints: include failure modes and recovery, include performance model and limits, avoid data races and undefined behavior, include security threat model (defensive only), include verification strategy, include test vectors and fuzz strategy, include backward compatibility and migration plan
Assume partial data corruption; include scrubbing strategy.
Deliverable: Provide a TLA+-style state machine (pseudo), safety/liveness properties, and a model-checking strategy. Include an implementation sketch and test vectors.
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Determinism: replay of the same event log yields identical outputs.
- Safety: state transitions preserve invariants; no partial commit leaks.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
**Failure modes & recovery**
- Network partition: minority cannot commit; clients receive retriable errors.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Property tests against a pure reference model (state machine).
- Fuzzing of parsers/framers/validators with corpus seeds.
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
**Snippet**
```tla
VARIABLES state, log, seen
Init == state = [k \in Keys |-> <<0, NULL>>] /\ log = << >> /\ seen = [r \in ReqIds |-> NULL]
Put(req, k, v) ==
IF seen[req] # NULL THEN UNCHANGED <<state, log, seen>>
ELSE
LET ver == state[k][1] + 1 IN
/\ state' = [state EXCEPT ![k] = <<ver, v>>]
/\ log' = Append(log, <<req, k, v, ver>>)
/\ seen' = [seen EXCEPT ![req] = <<"ok", ver>>]
Safety == \A k \in Keys: state[k][1] >= 0
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"tla+",
"model-checking",
"state-machines"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000008
|
tla_state_machine
|
expert
|
tla+
|
Task type: tla_state_machine
Scenario: identity and access
Domain focus: program synthesis (safe)
Primary language: tla+
Difficulty: expert
Scale/SLO: 1M msgs/min
Component: component_rbwquxuy
Constraints: include performance model and limits, include test vectors and fuzz strategy, assume adversarial inputs; validate everything, include verification strategy, explicit contracts and invariants, avoid data races and undefined behavior, include failure modes and recovery
Assume crash-only processes; recovery must be deterministic.
Deliverable: Provide a TLA+-style state machine (pseudo), safety/liveness properties, and a model-checking strategy. Include an implementation sketch and test vectors.
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Liveness: under bounded faults and stable network, progress occurs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Safety: state transitions preserve invariants; no partial commit leaks.
**Failure modes & recovery**
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Deterministic simulation with fault injection (crash/partition/latency).
- Property tests against a pure reference model (state machine).
**Snippet**
```tla
VARIABLES state, log, seen
Init == state = [k \in Keys |-> <<0, NULL>>] /\ log = << >> /\ seen = [r \in ReqIds |-> NULL]
Put(req, k, v) ==
IF seen[req] # NULL THEN UNCHANGED <<state, log, seen>>
ELSE
LET ver == state[k][1] + 1 IN
/\ state' = [state EXCEPT ![k] = <<ver, v>>]
/\ log' = Append(log, <<req, k, v, ver>>)
/\ seen' = [seen EXCEPT ![req] = <<"ok", ver>>]
Safety == \A k \in Keys: state[k][1] >= 0
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"tla+",
"model-checking",
"state-machines"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000009
|
tla_state_machine
|
hard
|
tla+
|
Task type: tla_state_machine
Scenario: rate limit gateway
Domain focus: distributed storage
Primary language: tla+
Difficulty: hard
Scale/SLO: 50 TB/day ingestion
Component: component_mesobenv
Constraints: include deterministic replay plan, include performance model and limits, include backward compatibility and migration plan, avoid data races and undefined behavior, include test vectors and fuzz strategy, assume adversarial inputs; validate everything
Assume crash-only processes; recovery must be deterministic.
Deliverable: Provide a TLA+-style state machine (pseudo), safety/liveness properties, and a model-checking strategy. Include an implementation sketch and test vectors.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Safety: state transitions preserve invariants; no partial commit leaks.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Property tests against a pure reference model (state machine).
- Fuzzing of parsers/framers/validators with corpus seeds.
- Deterministic simulation with fault injection (crash/partition/latency).
**Snippet**
```tla
VARIABLES state, log, seen
Init == state = [k \in Keys |-> <<0, NULL>>] /\ log = << >> /\ seen = [r \in ReqIds |-> NULL]
Put(req, k, v) ==
IF seen[req] # NULL THEN UNCHANGED <<state, log, seen>>
ELSE
LET ver == state[k][1] + 1 IN
/\ state' = [state EXCEPT ![k] = <<ver, v>>]
/\ log' = Append(log, <<req, k, v, ver>>)
/\ seen' = [seen EXCEPT ![req] = <<"ok", ver>>]
Safety == \A k \in Keys: state[k][1] >= 0
```
Hard checks: fault injection tests gate merges; perf thresholds enforced in CI.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"tla+",
"model-checking",
"state-machines"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000010
|
tla_state_machine
|
hard
|
tla+
|
Task type: tla_state_machine
Scenario: graph query service
Domain focus: data lineage & governance
Primary language: tla+
Difficulty: hard
Scale/SLO: p99 < 50ms
Component: component_ipxhbaoi
Constraints: include performance model and limits, include security threat model (defensive only), avoid data races and undefined behavior, include test vectors and fuzz strategy, include verification strategy, assume adversarial inputs; validate everything
Assume partial data corruption; include scrubbing strategy.
Deliverable: Provide a TLA+-style state machine (pseudo), safety/liveness properties, and a model-checking strategy. Include an implementation sketch and test vectors.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Liveness: under bounded faults and stable network, progress occurs.
- Determinism: replay of the same event log yields identical outputs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
**Failure modes & recovery**
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Deterministic simulation with fault injection (crash/partition/latency).
- Fuzzing of parsers/framers/validators with corpus seeds.
- Property tests against a pure reference model (state machine).
**Snippet**
```tla
VARIABLES state, log, seen
Init == state = [k \in Keys |-> <<0, NULL>>] /\ log = << >> /\ seen = [r \in ReqIds |-> NULL]
Put(req, k, v) ==
IF seen[req] # NULL THEN UNCHANGED <<state, log, seen>>
ELSE
LET ver == state[k][1] + 1 IN
/\ state' = [state EXCEPT ![k] = <<ver, v>>]
/\ log' = Append(log, <<req, k, v, ver>>)
/\ seen' = [seen EXCEPT ![req] = <<"ok", ver>>]
Safety == \A k \in Keys: state[k][1] >= 0
```
Hard checks: fault injection tests gate merges; perf thresholds enforced in CI.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"tla+",
"model-checking",
"state-machines"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000011
|
tla_state_machine
|
expert+
|
tla+
|
Task type: tla_state_machine
Scenario: rate limit gateway
Domain focus: secure enclaves (defensive)
Primary language: tla+
Difficulty: expert+
Scale/SLO: 50 TB/day ingestion
Component: component_qbqjiobn
Constraints: include deterministic replay plan, include verification strategy, assume adversarial inputs; validate everything, include security threat model (defensive only), include failure modes and recovery, include test vectors and fuzz strategy, avoid data races and undefined behavior
Assume crash-only processes; recovery must be deterministic.
Deliverable: Provide a TLA+-style state machine (pseudo), safety/liveness properties, and a model-checking strategy. Include an implementation sketch and test vectors.
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Liveness: under bounded faults and stable network, progress occurs.
- Safety: state transitions preserve invariants; no partial commit leaks.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Fuzzing of parsers/framers/validators with corpus seeds.
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Property tests against a pure reference model (state machine).
**Snippet**
```tla
VARIABLES state, log, seen
Init == state = [k \in Keys |-> <<0, NULL>>] /\ log = << >> /\ seen = [r \in ReqIds |-> NULL]
Put(req, k, v) ==
IF seen[req] # NULL THEN UNCHANGED <<state, log, seen>>
ELSE
LET ver == state[k][1] + 1 IN
/\ state' = [state EXCEPT ![k] = <<ver, v>>]
/\ log' = Append(log, <<req, k, v, ver>>)
/\ seen' = [seen EXCEPT ![req] = <<"ok", ver>>]
Safety == \A k \in Keys: state[k][1] >= 0
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"tla+",
"model-checking",
"state-machines"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000012
|
smt_constraint_model
|
hard
|
smtlib
|
Task type: smt_constraint_model
Scenario: document indexing pipeline
Domain focus: edge robotics (safe)
Primary language: smtlib
Difficulty: hard
Scale/SLO: p99 < 150ms
Component: component_bfhoxekx
Constraints: avoid data races and undefined behavior, include backward compatibility and migration plan, explicit contracts and invariants, include test vectors and fuzz strategy, include security threat model (defensive only)
Assume crash-only processes; recovery must be deterministic.
Deliverable: Provide an SMT constraint model (or Python-to-SMT) for correctness/optimization; include sample instances and how to validate solutions.
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Liveness: under bounded faults and stable network, progress occurs.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Fuzzing of parsers/framers/validators with corpus seeds.
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Property tests against a pure reference model (state machine).
**Snippet**
```smtlib
; Find an assignment minimizing cost while satisfying constraints
(declare-const x Int)
(declare-const y Int)
(assert (and (>= x 0) (>= y 0) (<= (+ x y) 10)))
(minimize (+ (* 3 x) (* 2 y)))
(check-sat)
(get-model)
```
Hard checks: fault injection tests gate merges; perf thresholds enforced in CI.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"smtlib",
"constraints",
"smt"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000013
|
smt_constraint_model
|
hard
|
smtlib
|
Task type: smt_constraint_model
Scenario: feature-flag evaluation
Domain focus: network protocols
Primary language: smtlib
Difficulty: hard
Scale/SLO: 1M msgs/min
Component: component_vtmvtpqy
Constraints: assume adversarial inputs; validate everything, include performance model and limits, include failure modes and recovery, avoid data races and undefined behavior, include deterministic replay plan, include verification strategy, include security threat model (defensive only)
Assume crash-only processes; recovery must be deterministic.
Deliverable: Provide an SMT constraint model (or Python-to-SMT) for correctness/optimization; include sample instances and how to validate solutions.
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Safety: state transitions preserve invariants; no partial commit leaks.
- Liveness: under bounded faults and stable network, progress occurs.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Property tests against a pure reference model (state machine).
- Deterministic simulation with fault injection (crash/partition/latency).
**Snippet**
```smtlib
; Find an assignment minimizing cost while satisfying constraints
(declare-const x Int)
(declare-const y Int)
(assert (and (>= x 0) (>= y 0) (<= (+ x y) 10)))
(minimize (+ (* 3 x) (* 2 y)))
(check-sat)
(get-model)
```
Hard checks: fault injection tests gate merges; perf thresholds enforced in CI.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"smtlib",
"constraints",
"smt"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000014
|
smt_constraint_model
|
expert
|
python
|
Task type: smt_constraint_model
Scenario: edge sync
Domain focus: program synthesis (safe)
Primary language: python
Difficulty: expert
Scale/SLO: 99.99% availability
Component: component_ykyvyyle
Constraints: avoid data races and undefined behavior, include backward compatibility and migration plan, explicit contracts and invariants, assume adversarial inputs; validate everything, include test vectors and fuzz strategy, include security threat model (defensive only), include verification strategy
Assume tight memory budget and cold-start constraints.
Deliverable: Provide an SMT constraint model (or Python-to-SMT) for correctness/optimization; include sample instances and how to validate solutions.
|
Output: elite engineering answer optimized for correctness, performance, and operability.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Safety: state transitions preserve invariants; no partial commit leaks.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Deterministic simulation with fault injection (crash/partition/latency).
- Fuzzing of parsers/framers/validators with corpus seeds.
**Snippet**
```smtlib
; Find an assignment minimizing cost while satisfying constraints
(declare-const x Int)
(declare-const y Int)
(assert (and (>= x 0) (>= y 0) (<= (+ x y) 10)))
(minimize (+ (* 3 x) (* 2 y)))
(check-sat)
(get-model)
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"python",
"constraints",
"smt"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000015
|
smt_constraint_model
|
expert
|
python
|
Task type: smt_constraint_model
Scenario: payment ledger
Domain focus: network protocols
Primary language: python
Difficulty: expert
Scale/SLO: 10k RPS peak
Component: component_epblhesv
Constraints: explicit contracts and invariants, include failure modes and recovery, assume adversarial inputs; validate everything, include backward compatibility and migration plan, include security threat model (defensive only), include deterministic replay plan, include performance model and limits
Assume tight memory budget and cold-start constraints.
Deliverable: Provide an SMT constraint model (or Python-to-SMT) for correctness/optimization; include sample instances and how to validate solutions.
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Determinism: replay of the same event log yields identical outputs.
- Safety: state transitions preserve invariants; no partial commit leaks.
- Liveness: under bounded faults and stable network, progress occurs.
**Failure modes & recovery**
- Network partition: minority cannot commit; clients receive retriable errors.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Deterministic simulation with fault injection (crash/partition/latency).
- Property tests against a pure reference model (state machine).
**Snippet**
```smtlib
; Find an assignment minimizing cost while satisfying constraints
(declare-const x Int)
(declare-const y Int)
(assert (and (>= x 0) (>= y 0) (<= (+ x y) 10)))
(minimize (+ (* 3 x) (* 2 y)))
(check-sat)
(get-model)
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"python",
"constraints",
"smt"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000016
|
distributed_algorithm
|
hard
|
typescript
|
Task type: distributed_algorithm
Scenario: multi-tenant event ingestion
Domain focus: program synthesis (safe)
Primary language: typescript
Difficulty: hard
Scale/SLO: 50 TB/day ingestion
Component: component_gjdkenmg
Constraints: include deterministic replay plan, include failure modes and recovery, include verification strategy, avoid data races and undefined behavior, include security threat model (defensive only), assume adversarial inputs; validate everything
Assume weekly network partitions.
Deliverable: Design an algorithm with message flows and correctness arguments (safety + liveness). Include failure handling and a minimal reference implementation skeleton.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Determinism: replay of the same event log yields identical outputs.
- Safety: state transitions preserve invariants; no partial commit leaks.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
**Failure modes & recovery**
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Property tests against a pure reference model (state machine).
- Fuzzing of parsers/framers/validators with corpus seeds.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Hard checks: fault injection tests gate merges; perf thresholds enforced in CI.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"typescript",
"distributed",
"consensus"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000017
|
distributed_algorithm
|
hard
|
python
|
Task type: distributed_algorithm
Scenario: feature-flag evaluation
Domain focus: formal verification
Primary language: python
Difficulty: hard
Scale/SLO: p99 < 50ms
Component: component_bxgtgskb
Constraints: include test vectors and fuzz strategy, include security threat model (defensive only), include failure modes and recovery, assume adversarial inputs; validate everything, include performance model and limits
Assume strict auditability and replayable history.
Deliverable: Design an algorithm with message flows and correctness arguments (safety + liveness). Include failure handling and a minimal reference implementation skeleton.
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Determinism: replay of the same event log yields identical outputs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Safety: state transitions preserve invariants; no partial commit leaks.
**Failure modes & recovery**
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Deterministic simulation with fault injection (crash/partition/latency).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Property tests against a pure reference model (state machine).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Hard checks: fault injection tests gate merges; perf thresholds enforced in CI.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"python",
"distributed",
"consensus"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000018
|
distributed_algorithm
|
expert+
|
typescript
|
Task type: distributed_algorithm
Scenario: document indexing pipeline
Domain focus: edge robotics (safe)
Primary language: typescript
Difficulty: expert+
Scale/SLO: 100k RPS peak
Component: component_lekahwkh
Constraints: include deterministic replay plan, include performance model and limits, include failure modes and recovery, explicit contracts and invariants, include security threat model (defensive only), include test vectors and fuzz strategy
Assume tight memory budget and cold-start constraints.
Deliverable: Design an algorithm with message flows and correctness arguments (safety + liveness). Include failure handling and a minimal reference implementation skeleton.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Safety: state transitions preserve invariants; no partial commit leaks.
- Liveness: under bounded faults and stable network, progress occurs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
**Failure modes & recovery**
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Property tests against a pure reference model (state machine).
- Fuzzing of parsers/framers/validators with corpus seeds.
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"typescript",
"distributed",
"consensus"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000019
|
distributed_algorithm
|
expert+
|
sql
|
Task type: distributed_algorithm
Scenario: document indexing pipeline
Domain focus: GPU serving
Primary language: sql
Difficulty: expert+
Scale/SLO: p99 < 150ms
Component: component_unklwuka
Constraints: include performance model and limits, include security threat model (defensive only), include verification strategy, assume adversarial inputs; validate everything, include backward compatibility and migration plan
Assume strict auditability and replayable history.
Deliverable: Design an algorithm with message flows and correctness arguments (safety + liveness). Include failure handling and a minimal reference implementation skeleton.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Determinism: replay of the same event log yields identical outputs.
- Liveness: under bounded faults and stable network, progress occurs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
**Failure modes & recovery**
- Network partition: minority cannot commit; clients receive retriable errors.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Fuzzing of parsers/framers/validators with corpus seeds.
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Property tests against a pure reference model (state machine).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"sql",
"distributed",
"consensus"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000020
|
distributed_algorithm
|
expert
|
typescript
|
Task type: distributed_algorithm
Scenario: identity and access
Domain focus: distributed storage
Primary language: typescript
Difficulty: expert
Scale/SLO: 1M msgs/min
Component: component_fywerxit
Constraints: include test vectors and fuzz strategy, include security threat model (defensive only), explicit contracts and invariants, include backward compatibility and migration plan, assume adversarial inputs; validate everything, include performance model and limits
Assume tight memory budget and cold-start constraints.
Deliverable: Design an algorithm with message flows and correctness arguments (safety + liveness). Include failure handling and a minimal reference implementation skeleton.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Determinism: replay of the same event log yields identical outputs.
- Safety: state transitions preserve invariants; no partial commit leaks.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
**Failure modes & recovery**
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Fuzzing of parsers/framers/validators with corpus seeds.
- Deterministic simulation with fault injection (crash/partition/latency).
- Property tests against a pure reference model (state machine).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"typescript",
"distributed",
"consensus"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000021
|
distributed_algorithm
|
hard
|
python
|
Task type: distributed_algorithm
Scenario: document indexing pipeline
Domain focus: kernel primitives
Primary language: python
Difficulty: hard
Scale/SLO: 99.99% availability
Component: component_lywlxsex
Constraints: explicit contracts and invariants, include backward compatibility and migration plan, include verification strategy, include failure modes and recovery, include test vectors and fuzz strategy
Assume weekly network partitions.
Deliverable: Design an algorithm with message flows and correctness arguments (safety + liveness). Include failure handling and a minimal reference implementation skeleton.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Determinism: replay of the same event log yields identical outputs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Safety: state transitions preserve invariants; no partial commit leaks.
**Failure modes & recovery**
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Fuzzing of parsers/framers/validators with corpus seeds.
- Property tests against a pure reference model (state machine).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Hard checks: fault injection tests gate merges; perf thresholds enforced in CI.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"python",
"distributed",
"consensus"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000022
|
distributed_algorithm
|
hard
|
typescript
|
Task type: distributed_algorithm
Scenario: time-series metrics store
Domain focus: secure enclaves (defensive)
Primary language: typescript
Difficulty: hard
Scale/SLO: 10k RPS peak
Component: component_znipibzo
Constraints: include verification strategy, include security threat model (defensive only), include deterministic replay plan, include failure modes and recovery, explicit contracts and invariants
Assume weekly network partitions.
Deliverable: Design an algorithm with message flows and correctness arguments (safety + liveness). Include failure handling and a minimal reference implementation skeleton.
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Determinism: replay of the same event log yields identical outputs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Liveness: under bounded faults and stable network, progress occurs.
**Failure modes & recovery**
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Fuzzing of parsers/framers/validators with corpus seeds.
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Property tests against a pure reference model (state machine).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Hard checks: fault injection tests gate merges; perf thresholds enforced in CI.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"typescript",
"distributed",
"consensus"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000023
|
distributed_algorithm
|
hard
|
bash
|
Task type: distributed_algorithm
Scenario: streaming ETL
Domain focus: kernel primitives
Primary language: bash
Difficulty: hard
Scale/SLO: p99 < 50ms
Component: component_jxckwpvu
Constraints: include failure modes and recovery, include security threat model (defensive only), include backward compatibility and migration plan, avoid data races and undefined behavior, include performance model and limits
Assume partial data corruption; include scrubbing strategy.
Deliverable: Design an algorithm with message flows and correctness arguments (safety + liveness). Include failure handling and a minimal reference implementation skeleton.
|
Output: elite engineering answer optimized for correctness, performance, and operability.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Liveness: under bounded faults and stable network, progress occurs.
- Safety: state transitions preserve invariants; no partial commit leaks.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
**Failure modes & recovery**
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Property tests against a pure reference model (state machine).
- Fuzzing of parsers/framers/validators with corpus seeds.
- Deterministic simulation with fault injection (crash/partition/latency).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Hard checks: fault injection tests gate merges; perf thresholds enforced in CI.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"bash",
"distributed",
"consensus"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000024
|
storage_engine
|
hard
|
bash
|
Task type: storage_engine
Scenario: edge sync
Domain focus: model checking
Primary language: bash
Difficulty: hard
Scale/SLO: 50 TB/day ingestion
Component: component_ywrsqlqt
Constraints: include backward compatibility and migration plan, explicit contracts and invariants, include failure modes and recovery, include test vectors and fuzz strategy, include security threat model (defensive only), include deterministic replay plan
Assume weekly network partitions.
Deliverable: Design a storage engine subsystem (WAL, snapshots, compaction). Include crash recovery invariants and a benchmark plan.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Liveness: under bounded faults and stable network, progress occurs.
- Determinism: replay of the same event log yields identical outputs.
- Safety: state transitions preserve invariants; no partial commit leaks.
**Failure modes & recovery**
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Network partition: minority cannot commit; clients receive retriable errors.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Deterministic simulation with fault injection (crash/partition/latency).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Property tests against a pure reference model (state machine).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Hard checks: fault injection tests gate merges; perf thresholds enforced in CI.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"bash",
"storage",
"wal",
"lsm"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000025
|
storage_engine
|
expert
|
typescript
|
Task type: storage_engine
Scenario: graph query service
Domain focus: fault injection & chaos engineering
Primary language: typescript
Difficulty: expert
Scale/SLO: 10k RPS peak
Component: component_wbymgcde
Constraints: include test vectors and fuzz strategy, include security threat model (defensive only), include failure modes and recovery, assume adversarial inputs; validate everything, include verification strategy, avoid data races and undefined behavior
Assume strict auditability and replayable history.
Deliverable: Design a storage engine subsystem (WAL, snapshots, compaction). Include crash recovery invariants and a benchmark plan.
|
Output: elite engineering answer optimized for correctness, performance, and operability.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Liveness: under bounded faults and stable network, progress occurs.
- Determinism: replay of the same event log yields identical outputs.
- Safety: state transitions preserve invariants; no partial commit leaks.
**Failure modes & recovery**
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Deterministic simulation with fault injection (crash/partition/latency).
- Fuzzing of parsers/framers/validators with corpus seeds.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"typescript",
"storage",
"wal",
"lsm"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000026
|
storage_engine
|
hard
|
go
|
Task type: storage_engine
Scenario: job scheduler
Domain focus: data lineage & governance
Primary language: go
Difficulty: hard
Scale/SLO: p99 < 50ms
Component: component_jvyvrfax
Constraints: include performance model and limits, include verification strategy, include test vectors and fuzz strategy, explicit contracts and invariants, include deterministic replay plan, assume adversarial inputs; validate everything, avoid data races and undefined behavior
Assume partial data corruption; include scrubbing strategy.
Deliverable: Design a storage engine subsystem (WAL, snapshots, compaction). Include crash recovery invariants and a benchmark plan.
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Liveness: under bounded faults and stable network, progress occurs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Safety: state transitions preserve invariants; no partial commit leaks.
**Failure modes & recovery**
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Fuzzing of parsers/framers/validators with corpus seeds.
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Deterministic simulation with fault injection (crash/partition/latency).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Hard checks: fault injection tests gate merges; perf thresholds enforced in CI.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"go",
"storage",
"wal",
"lsm"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000027
|
storage_engine
|
hard
|
typescript
|
Task type: storage_engine
Scenario: payment ledger
Domain focus: runtime systems
Primary language: typescript
Difficulty: hard
Scale/SLO: 99.99% availability
Component: component_svprsrig
Constraints: assume adversarial inputs; validate everything, avoid data races and undefined behavior, explicit contracts and invariants, include test vectors and fuzz strategy, include verification strategy
Assume partial data corruption; include scrubbing strategy.
Deliverable: Design a storage engine subsystem (WAL, snapshots, compaction). Include crash recovery invariants and a benchmark plan.
|
Output: elite engineering answer optimized for correctness, performance, and operability.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Determinism: replay of the same event log yields identical outputs.
- Liveness: under bounded faults and stable network, progress occurs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
**Failure modes & recovery**
- Network partition: minority cannot commit; clients receive retriable errors.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Deterministic simulation with fault injection (crash/partition/latency).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Property tests against a pure reference model (state machine).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Hard checks: fault injection tests gate merges; perf thresholds enforced in CI.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"typescript",
"storage",
"wal",
"lsm"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000028
|
storage_engine
|
expert+
|
bash
|
Task type: storage_engine
Scenario: job scheduler
Domain focus: GPU serving
Primary language: bash
Difficulty: expert+
Scale/SLO: p99 < 50ms
Component: component_lhjxmlui
Constraints: include verification strategy, include failure modes and recovery, explicit contracts and invariants, avoid data races and undefined behavior, include deterministic replay plan, include performance model and limits, include test vectors and fuzz strategy
Assume schema changes every sprint; must be backward compatible.
Deliverable: Design a storage engine subsystem (WAL, snapshots, compaction). Include crash recovery invariants and a benchmark plan.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Determinism: replay of the same event log yields identical outputs.
- Safety: state transitions preserve invariants; no partial commit leaks.
- Liveness: under bounded faults and stable network, progress occurs.
**Failure modes & recovery**
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Deterministic simulation with fault injection (crash/partition/latency).
- Fuzzing of parsers/framers/validators with corpus seeds.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"bash",
"storage",
"wal",
"lsm"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000029
|
storage_engine
|
hard
|
rust
|
Task type: storage_engine
Scenario: edge sync
Domain focus: kernel primitives
Primary language: rust
Difficulty: hard
Scale/SLO: multi-region active-active
Component: component_vnrwoivg
Constraints: avoid data races and undefined behavior, include backward compatibility and migration plan, include test vectors and fuzz strategy, include deterministic replay plan, assume adversarial inputs; validate everything, include verification strategy, include performance model and limits
Assume weekly network partitions.
Deliverable: Design a storage engine subsystem (WAL, snapshots, compaction). Include crash recovery invariants and a benchmark plan.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Determinism: replay of the same event log yields identical outputs.
- Liveness: under bounded faults and stable network, progress occurs.
**Failure modes & recovery**
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Fuzzing of parsers/framers/validators with corpus seeds.
- Deterministic simulation with fault injection (crash/partition/latency).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Hard checks: fault injection tests gate merges; perf thresholds enforced in CI.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"rust",
"storage",
"wal",
"lsm"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000030
|
query_optimizer
|
expert+
|
go
|
Task type: query_optimizer
Scenario: graph query service
Domain focus: query planning
Primary language: go
Difficulty: expert+
Scale/SLO: 1M msgs/min
Component: component_seijvkuz
Constraints: include failure modes and recovery, include backward compatibility and migration plan, include deterministic replay plan, explicit contracts and invariants, include verification strategy, assume adversarial inputs; validate everything, include performance model and limits
Assume schema changes every sprint; must be backward compatible.
Deliverable: Design a cost-based optimizer slice: logical rules, physical operators, and cost model. Include regression tests and query-plan explain examples.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Liveness: under bounded faults and stable network, progress occurs.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Fuzzing of parsers/framers/validators with corpus seeds.
- Deterministic simulation with fault injection (crash/partition/latency).
**Snippet**
```python
# Minimal cost model skeleton
from dataclasses import dataclass
@dataclass(frozen=True)
class Plan:
op: str
cost: float
children: tuple["Plan", ...] = ()
def choose_best(plans: list[Plan]) -> Plan:
return min(plans, key=lambda p: p.cost)
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"go",
"databases",
"cost-model"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000031
|
query_optimizer
|
expert
|
typescript
|
Task type: query_optimizer
Scenario: real-time notification hub
Domain focus: real-time scheduling
Primary language: typescript
Difficulty: expert
Scale/SLO: p99 < 50ms
Component: component_zzpfgzvg
Constraints: include verification strategy, avoid data races and undefined behavior, include deterministic replay plan, include backward compatibility and migration plan, assume adversarial inputs; validate everything, include performance model and limits, include test vectors and fuzz strategy
Assume tight memory budget and cold-start constraints.
Deliverable: Design a cost-based optimizer slice: logical rules, physical operators, and cost model. Include regression tests and query-plan explain examples.
|
Output: elite engineering answer optimized for correctness, performance, and operability.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Liveness: under bounded faults and stable network, progress occurs.
- Determinism: replay of the same event log yields identical outputs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
**Failure modes & recovery**
- Network partition: minority cannot commit; clients receive retriable errors.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Deterministic simulation with fault injection (crash/partition/latency).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Fuzzing of parsers/framers/validators with corpus seeds.
**Snippet**
```python
# Minimal cost model skeleton
from dataclasses import dataclass
@dataclass(frozen=True)
class Plan:
op: str
cost: float
children: tuple["Plan", ...] = ()
def choose_best(plans: list[Plan]) -> Plan:
return min(plans, key=lambda p: p.cost)
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"typescript",
"databases",
"cost-model"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000032
|
query_optimizer
|
expert+
|
rust
|
Task type: query_optimizer
Scenario: rate limit gateway
Domain focus: observability platforms
Primary language: rust
Difficulty: expert+
Scale/SLO: multi-region active-active
Component: component_tojeuzwt
Constraints: include verification strategy, include deterministic replay plan, include failure modes and recovery, assume adversarial inputs; validate everything, include security threat model (defensive only)
Assume crash-only processes; recovery must be deterministic.
Deliverable: Design a cost-based optimizer slice: logical rules, physical operators, and cost model. Include regression tests and query-plan explain examples.
|
Output: elite engineering answer optimized for correctness, performance, and operability.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Liveness: under bounded faults and stable network, progress occurs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Deterministic simulation with fault injection (crash/partition/latency).
- Fuzzing of parsers/framers/validators with corpus seeds.
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
**Snippet**
```python
# Minimal cost model skeleton
from dataclasses import dataclass
@dataclass(frozen=True)
class Plan:
op: str
cost: float
children: tuple["Plan", ...] = ()
def choose_best(plans: list[Plan]) -> Plan:
return min(plans, key=lambda p: p.cost)
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"rust",
"databases",
"cost-model"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000033
|
query_optimizer
|
hard
|
typescript
|
Task type: query_optimizer
Scenario: streaming ETL
Domain focus: runtime systems
Primary language: typescript
Difficulty: hard
Scale/SLO: p99 < 150ms
Component: component_ymyopobv
Constraints: explicit contracts and invariants, avoid data races and undefined behavior, include backward compatibility and migration plan, include verification strategy, include deterministic replay plan, include test vectors and fuzz strategy
Assume weekly network partitions.
Deliverable: Design a cost-based optimizer slice: logical rules, physical operators, and cost model. Include regression tests and query-plan explain examples.
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Determinism: replay of the same event log yields identical outputs.
- Liveness: under bounded faults and stable network, progress occurs.
**Failure modes & recovery**
- Network partition: minority cannot commit; clients receive retriable errors.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Property tests against a pure reference model (state machine).
- Fuzzing of parsers/framers/validators with corpus seeds.
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
**Snippet**
```python
# Minimal cost model skeleton
from dataclasses import dataclass
@dataclass(frozen=True)
class Plan:
op: str
cost: float
children: tuple["Plan", ...] = ()
def choose_best(plans: list[Plan]) -> Plan:
return min(plans, key=lambda p: p.cost)
```
Hard checks: fault injection tests gate merges; perf thresholds enforced in CI.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"typescript",
"databases",
"cost-model"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000034
|
query_optimizer
|
expert+
|
sql
|
Task type: query_optimizer
Scenario: identity and access
Domain focus: model checking
Primary language: sql
Difficulty: expert+
Scale/SLO: multi-region active-active
Component: component_jercwlrf
Constraints: assume adversarial inputs; validate everything, include backward compatibility and migration plan, explicit contracts and invariants, include verification strategy, include failure modes and recovery, include deterministic replay plan
Assume tight memory budget and cold-start constraints.
Deliverable: Design a cost-based optimizer slice: logical rules, physical operators, and cost model. Include regression tests and query-plan explain examples.
|
Output: elite engineering answer optimized for correctness, performance, and operability.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Safety: state transitions preserve invariants; no partial commit leaks.
- Liveness: under bounded faults and stable network, progress occurs.
**Failure modes & recovery**
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Deterministic simulation with fault injection (crash/partition/latency).
- Property tests against a pure reference model (state machine).
- Fuzzing of parsers/framers/validators with corpus seeds.
**Snippet**
```python
# Minimal cost model skeleton
from dataclasses import dataclass
@dataclass(frozen=True)
class Plan:
op: str
cost: float
children: tuple["Plan", ...] = ()
def choose_best(plans: list[Plan]) -> Plan:
return min(plans, key=lambda p: p.cost)
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"sql",
"databases",
"cost-model"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000035
|
query_optimizer
|
expert+
|
go
|
Task type: query_optimizer
Scenario: job scheduler
Domain focus: data lineage & governance
Primary language: go
Difficulty: expert+
Scale/SLO: 1M msgs/min
Component: component_ffitpcwn
Constraints: explicit contracts and invariants, include performance model and limits, include failure modes and recovery, assume adversarial inputs; validate everything, include deterministic replay plan, avoid data races and undefined behavior
Assume weekly network partitions.
Deliverable: Design a cost-based optimizer slice: logical rules, physical operators, and cost model. Include regression tests and query-plan explain examples.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Determinism: replay of the same event log yields identical outputs.
- Liveness: under bounded faults and stable network, progress occurs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
**Failure modes & recovery**
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Network partition: minority cannot commit; clients receive retriable errors.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Property tests against a pure reference model (state machine).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Fuzzing of parsers/framers/validators with corpus seeds.
**Snippet**
```python
# Minimal cost model skeleton
from dataclasses import dataclass
@dataclass(frozen=True)
class Plan:
op: str
cost: float
children: tuple["Plan", ...] = ()
def choose_best(plans: list[Plan]) -> Plan:
return min(plans, key=lambda p: p.cost)
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"go",
"databases",
"cost-model"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000036
|
compiler_frontend
|
hard
|
python
|
Task type: compiler_frontend
Scenario: time-series metrics store
Domain focus: stream processing
Primary language: python
Difficulty: hard
Scale/SLO: 10k RPS peak
Component: component_kqywwksn
Constraints: avoid data races and undefined behavior, assume adversarial inputs; validate everything, include failure modes and recovery, include performance model and limits, explicit contracts and invariants
Assume partial data corruption; include scrubbing strategy.
Deliverable: Design a DSL language frontend: lexer/parser, AST, type checking, error reporting, and tests.
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Safety: state transitions preserve invariants; no partial commit leaks.
- Liveness: under bounded faults and stable network, progress occurs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
**Failure modes & recovery**
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Property tests against a pure reference model (state machine).
- Deterministic simulation with fault injection (crash/partition/latency).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Hard checks: fault injection tests gate merges; perf thresholds enforced in CI.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"python",
"parsing",
"type-systems"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000037
|
compiler_frontend
|
expert+
|
go
|
Task type: compiler_frontend
Scenario: feature-flag evaluation
Domain focus: zero-downtime migrations
Primary language: go
Difficulty: expert+
Scale/SLO: p99 < 50ms
Component: component_svqbssim
Constraints: include failure modes and recovery, include backward compatibility and migration plan, avoid data races and undefined behavior, include deterministic replay plan, assume adversarial inputs; validate everything, include test vectors and fuzz strategy
Assume partial data corruption; include scrubbing strategy.
Deliverable: Design a DSL language frontend: lexer/parser, AST, type checking, error reporting, and tests.
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Determinism: replay of the same event log yields identical outputs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Liveness: under bounded faults and stable network, progress occurs.
**Failure modes & recovery**
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Deterministic simulation with fault injection (crash/partition/latency).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Property tests against a pure reference model (state machine).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"go",
"parsing",
"type-systems"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000038
|
compiler_frontend
|
expert
|
go
|
Task type: compiler_frontend
Scenario: graph query service
Domain focus: static analysis
Primary language: go
Difficulty: expert
Scale/SLO: 10k RPS peak
Component: component_rcvixnxd
Constraints: include deterministic replay plan, include backward compatibility and migration plan, include failure modes and recovery, explicit contracts and invariants, include verification strategy
Assume schema changes every sprint; must be backward compatible.
Deliverable: Design a DSL language frontend: lexer/parser, AST, type checking, error reporting, and tests.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Safety: state transitions preserve invariants; no partial commit leaks.
- Determinism: replay of the same event log yields identical outputs.
- Liveness: under bounded faults and stable network, progress occurs.
**Failure modes & recovery**
- Network partition: minority cannot commit; clients receive retriable errors.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Deterministic simulation with fault injection (crash/partition/latency).
- Property tests against a pure reference model (state machine).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"go",
"parsing",
"type-systems"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000039
|
compiler_frontend
|
expert
|
rust
|
Task type: compiler_frontend
Scenario: document indexing pipeline
Domain focus: runtime systems
Primary language: rust
Difficulty: expert
Scale/SLO: 10k RPS peak
Component: component_jccbqhlj
Constraints: avoid data races and undefined behavior, include failure modes and recovery, include test vectors and fuzz strategy, include verification strategy, include security threat model (defensive only), include deterministic replay plan, include backward compatibility and migration plan
Assume weekly network partitions.
Deliverable: Design a DSL language frontend: lexer/parser, AST, type checking, error reporting, and tests.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Determinism: replay of the same event log yields identical outputs.
- Liveness: under bounded faults and stable network, progress occurs.
- Safety: state transitions preserve invariants; no partial commit leaks.
**Failure modes & recovery**
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Property tests against a pure reference model (state machine).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Fuzzing of parsers/framers/validators with corpus seeds.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"rust",
"parsing",
"type-systems"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000040
|
compiler_frontend
|
hard
|
typescript
|
Task type: compiler_frontend
Scenario: graph query service
Domain focus: stream processing
Primary language: typescript
Difficulty: hard
Scale/SLO: p99 < 150ms
Component: component_mhcrfobs
Constraints: include verification strategy, include backward compatibility and migration plan, include security threat model (defensive only), avoid data races and undefined behavior, assume adversarial inputs; validate everything, explicit contracts and invariants, include test vectors and fuzz strategy
Assume partial data corruption; include scrubbing strategy.
Deliverable: Design a DSL language frontend: lexer/parser, AST, type checking, error reporting, and tests.
|
Output: elite engineering answer optimized for correctness, performance, and operability.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Determinism: replay of the same event log yields identical outputs.
- Liveness: under bounded faults and stable network, progress occurs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
**Failure modes & recovery**
- Network partition: minority cannot commit; clients receive retriable errors.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Property tests against a pure reference model (state machine).
- Deterministic simulation with fault injection (crash/partition/latency).
- Fuzzing of parsers/framers/validators with corpus seeds.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Hard checks: fault injection tests gate merges; perf thresholds enforced in CI.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"typescript",
"parsing",
"type-systems"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000041
|
compiler_frontend
|
expert
|
python
|
Task type: compiler_frontend
Scenario: graph query service
Domain focus: observability platforms
Primary language: python
Difficulty: expert
Scale/SLO: 1M msgs/min
Component: component_ybghvgqu
Constraints: include backward compatibility and migration plan, include verification strategy, include failure modes and recovery, avoid data races and undefined behavior, assume adversarial inputs; validate everything, explicit contracts and invariants, include performance model and limits
Assume schema changes every sprint; must be backward compatible.
Deliverable: Design a DSL language frontend: lexer/parser, AST, type checking, error reporting, and tests.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Determinism: replay of the same event log yields identical outputs.
- Safety: state transitions preserve invariants; no partial commit leaks.
**Failure modes & recovery**
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Deterministic simulation with fault injection (crash/partition/latency).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Fuzzing of parsers/framers/validators with corpus seeds.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"python",
"parsing",
"type-systems"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000042
|
compiler_backend_ir
|
expert
|
rust
|
Task type: compiler_backend_ir
Scenario: document indexing pipeline
Domain focus: network protocols
Primary language: rust
Difficulty: expert
Scale/SLO: 100k RPS peak
Component: component_shwtlhhg
Constraints: include failure modes and recovery, explicit contracts and invariants, include test vectors and fuzz strategy, include backward compatibility and migration plan, include performance model and limits, avoid data races and undefined behavior
Assume strict auditability and replayable history.
Deliverable: Design an IR and lowering pipeline; include an optimization pass and correctness checks. Provide minimal code skeleton and tests.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Safety: state transitions preserve invariants; no partial commit leaks.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Network partition: minority cannot commit; clients receive retriable errors.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Property tests against a pure reference model (state machine).
- Deterministic simulation with fault injection (crash/partition/latency).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"rust",
"ir",
"codegen"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000043
|
compiler_backend_ir
|
expert
|
cpp
|
Task type: compiler_backend_ir
Scenario: graph query service
Domain focus: GPU serving
Primary language: cpp
Difficulty: expert
Scale/SLO: p99 < 150ms
Component: component_nuflpeob
Constraints: include security threat model (defensive only), include verification strategy, avoid data races and undefined behavior, assume adversarial inputs; validate everything, include failure modes and recovery
Assume weekly network partitions.
Deliverable: Design an IR and lowering pipeline; include an optimization pass and correctness checks. Provide minimal code skeleton and tests.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Safety: state transitions preserve invariants; no partial commit leaks.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Fuzzing of parsers/framers/validators with corpus seeds.
- Property tests against a pure reference model (state machine).
- Deterministic simulation with fault injection (crash/partition/latency).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"cpp",
"ir",
"codegen"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000044
|
compiler_backend_ir
|
hard
|
cpp
|
Task type: compiler_backend_ir
Scenario: edge sync
Domain focus: compiler toolchains
Primary language: cpp
Difficulty: hard
Scale/SLO: p99 < 150ms
Component: component_vjhcnfzj
Constraints: avoid data races and undefined behavior, include performance model and limits, include test vectors and fuzz strategy, include failure modes and recovery, include deterministic replay plan
Assume tight memory budget and cold-start constraints.
Deliverable: Design an IR and lowering pipeline; include an optimization pass and correctness checks. Provide minimal code skeleton and tests.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Safety: state transitions preserve invariants; no partial commit leaks.
- Liveness: under bounded faults and stable network, progress occurs.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Network partition: minority cannot commit; clients receive retriable errors.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Fuzzing of parsers/framers/validators with corpus seeds.
- Property tests against a pure reference model (state machine).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Hard checks: fault injection tests gate merges; perf thresholds enforced in CI.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"cpp",
"ir",
"codegen"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000045
|
compiler_backend_ir
|
expert
|
rust
|
Task type: compiler_backend_ir
Scenario: payment ledger
Domain focus: large-scale ML systems
Primary language: rust
Difficulty: expert
Scale/SLO: p99 < 150ms
Component: component_wukulnnm
Constraints: include failure modes and recovery, include verification strategy, explicit contracts and invariants, include test vectors and fuzz strategy, include deterministic replay plan, assume adversarial inputs; validate everything, avoid data races and undefined behavior
Assume tight memory budget and cold-start constraints.
Deliverable: Design an IR and lowering pipeline; include an optimization pass and correctness checks. Provide minimal code skeleton and tests.
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Determinism: replay of the same event log yields identical outputs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Safety: state transitions preserve invariants; no partial commit leaks.
**Failure modes & recovery**
- Network partition: minority cannot commit; clients receive retriable errors.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Property tests against a pure reference model (state machine).
- Fuzzing of parsers/framers/validators with corpus seeds.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"rust",
"ir",
"codegen"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000046
|
compiler_backend_ir
|
expert
|
cpp
|
Task type: compiler_backend_ir
Scenario: multi-tenant event ingestion
Domain focus: GPU serving
Primary language: cpp
Difficulty: expert
Scale/SLO: p99 < 150ms
Component: component_ewqelrcb
Constraints: include backward compatibility and migration plan, include security threat model (defensive only), explicit contracts and invariants, include deterministic replay plan, assume adversarial inputs; validate everything
Assume schema changes every sprint; must be backward compatible.
Deliverable: Design an IR and lowering pipeline; include an optimization pass and correctness checks. Provide minimal code skeleton and tests.
|
Output: elite engineering answer optimized for correctness, performance, and operability.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Determinism: replay of the same event log yields identical outputs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Liveness: under bounded faults and stable network, progress occurs.
**Failure modes & recovery**
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Network partition: minority cannot commit; clients receive retriable errors.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Fuzzing of parsers/framers/validators with corpus seeds.
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Property tests against a pure reference model (state machine).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"cpp",
"ir",
"codegen"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000047
|
compiler_backend_ir
|
expert
|
rust
|
Task type: compiler_backend_ir
Scenario: time-series metrics store
Domain focus: observability platforms
Primary language: rust
Difficulty: expert
Scale/SLO: 1M msgs/min
Component: component_utezyxlk
Constraints: include failure modes and recovery, include verification strategy, avoid data races and undefined behavior, explicit contracts and invariants, assume adversarial inputs; validate everything, include deterministic replay plan
Assume weekly network partitions.
Deliverable: Design an IR and lowering pipeline; include an optimization pass and correctness checks. Provide minimal code skeleton and tests.
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Safety: state transitions preserve invariants; no partial commit leaks.
- Liveness: under bounded faults and stable network, progress occurs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
**Failure modes & recovery**
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Fuzzing of parsers/framers/validators with corpus seeds.
- Property tests against a pure reference model (state machine).
- Deterministic simulation with fault injection (crash/partition/latency).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"rust",
"ir",
"codegen"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000048
|
static_analyzer
|
expert+
|
rust
|
Task type: static_analyzer
Scenario: time-series metrics store
Domain focus: fault injection & chaos engineering
Primary language: rust
Difficulty: expert+
Scale/SLO: p99 < 50ms
Component: component_fogtlwcu
Constraints: include deterministic replay plan, include verification strategy, explicit contracts and invariants, assume adversarial inputs; validate everything, include failure modes and recovery
Assume weekly network partitions.
Deliverable: Design a static analyzer for a safety property (e.g., taint/SQLi prevention); include rule set, false-positive strategy, and tests.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Liveness: under bounded faults and stable network, progress occurs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Network partition: minority cannot commit; clients receive retriable errors.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Fuzzing of parsers/framers/validators with corpus seeds.
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Property tests against a pure reference model (state machine).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"rust",
"static-analysis",
"security"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000049
|
static_analyzer
|
expert+
|
python
|
Task type: static_analyzer
Scenario: identity and access
Domain focus: high-frequency trading systems (safe engineering)
Primary language: python
Difficulty: expert+
Scale/SLO: 10k RPS peak
Component: component_gygowvfa
Constraints: include security threat model (defensive only), include verification strategy, include backward compatibility and migration plan, include performance model and limits, explicit contracts and invariants, include test vectors and fuzz strategy, include failure modes and recovery
Assume schema changes every sprint; must be backward compatible.
Deliverable: Design a static analyzer for a safety property (e.g., taint/SQLi prevention); include rule set, false-positive strategy, and tests.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Safety: state transitions preserve invariants; no partial commit leaks.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Property tests against a pure reference model (state machine).
- Deterministic simulation with fault injection (crash/partition/latency).
- Fuzzing of parsers/framers/validators with corpus seeds.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"python",
"static-analysis",
"security"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000050
|
static_analyzer
|
expert+
|
bash
|
Task type: static_analyzer
Scenario: multi-tenant event ingestion
Domain focus: model checking
Primary language: bash
Difficulty: expert+
Scale/SLO: 1M msgs/min
Component: component_kxlanhnp
Constraints: include backward compatibility and migration plan, include test vectors and fuzz strategy, avoid data races and undefined behavior, include performance model and limits, explicit contracts and invariants, include deterministic replay plan
Assume crash-only processes; recovery must be deterministic.
Deliverable: Design a static analyzer for a safety property (e.g., taint/SQLi prevention); include rule set, false-positive strategy, and tests.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Liveness: under bounded faults and stable network, progress occurs.
- Safety: state transitions preserve invariants; no partial commit leaks.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Network partition: minority cannot commit; clients receive retriable errors.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Deterministic simulation with fault injection (crash/partition/latency).
- Fuzzing of parsers/framers/validators with corpus seeds.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"bash",
"static-analysis",
"security"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000051
|
static_analyzer
|
expert+
|
sql
|
Task type: static_analyzer
Scenario: edge sync
Domain focus: data lineage & governance
Primary language: sql
Difficulty: expert+
Scale/SLO: p99 < 150ms
Component: component_xpkwmofl
Constraints: include security threat model (defensive only), avoid data races and undefined behavior, include backward compatibility and migration plan, include performance model and limits, assume adversarial inputs; validate everything, include deterministic replay plan
Assume tight memory budget and cold-start constraints.
Deliverable: Design a static analyzer for a safety property (e.g., taint/SQLi prevention); include rule set, false-positive strategy, and tests.
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Liveness: under bounded faults and stable network, progress occurs.
- Safety: state transitions preserve invariants; no partial commit leaks.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
**Failure modes & recovery**
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Property tests against a pure reference model (state machine).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Fuzzing of parsers/framers/validators with corpus seeds.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"sql",
"static-analysis",
"security"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000052
|
static_analyzer
|
hard
|
go
|
Task type: static_analyzer
Scenario: payment ledger
Domain focus: data lineage & governance
Primary language: go
Difficulty: hard
Scale/SLO: 50 TB/day ingestion
Component: component_xaqjxnun
Constraints: include test vectors and fuzz strategy, include verification strategy, explicit contracts and invariants, include security threat model (defensive only), avoid data races and undefined behavior, assume adversarial inputs; validate everything, include failure modes and recovery
Assume schema changes every sprint; must be backward compatible.
Deliverable: Design a static analyzer for a safety property (e.g., taint/SQLi prevention); include rule set, false-positive strategy, and tests.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Liveness: under bounded faults and stable network, progress occurs.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Deterministic simulation with fault injection (crash/partition/latency).
- Fuzzing of parsers/framers/validators with corpus seeds.
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Hard checks: fault injection tests gate merges; perf thresholds enforced in CI.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"go",
"static-analysis",
"security"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000053
|
static_analyzer
|
expert
|
rust
|
Task type: static_analyzer
Scenario: real-time notification hub
Domain focus: network protocols
Primary language: rust
Difficulty: expert
Scale/SLO: 1M msgs/min
Component: component_hnbmshhl
Constraints: avoid data races and undefined behavior, include security threat model (defensive only), include verification strategy, explicit contracts and invariants, assume adversarial inputs; validate everything, include test vectors and fuzz strategy, include deterministic replay plan
Assume hostile inputs and targeted abuse patterns.
Deliverable: Design a static analyzer for a safety property (e.g., taint/SQLi prevention); include rule set, false-positive strategy, and tests.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Determinism: replay of the same event log yields identical outputs.
- Safety: state transitions preserve invariants; no partial commit leaks.
- Liveness: under bounded faults and stable network, progress occurs.
**Failure modes & recovery**
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Property tests against a pure reference model (state machine).
- Fuzzing of parsers/framers/validators with corpus seeds.
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"rust",
"static-analysis",
"security"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000054
|
runtime_gc
|
expert+
|
bash
|
Task type: runtime_gc
Scenario: payment ledger
Domain focus: query planning
Primary language: bash
Difficulty: expert+
Scale/SLO: 99.99% availability
Component: component_lxvqvovy
Constraints: include performance model and limits, include backward compatibility and migration plan, explicit contracts and invariants, avoid data races and undefined behavior, include security threat model (defensive only), include failure modes and recovery
Assume crash-only processes; recovery must be deterministic.
Deliverable: Design a GC/runtime component (mark-sweep/arena/RC hybrid); include pause-time strategy and tests.
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Safety: state transitions preserve invariants; no partial commit leaks.
- Liveness: under bounded faults and stable network, progress occurs.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Network partition: minority cannot commit; clients receive retriable errors.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Fuzzing of parsers/framers/validators with corpus seeds.
- Property tests against a pure reference model (state machine).
- Deterministic simulation with fault injection (crash/partition/latency).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"bash",
"runtime",
"gc"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000055
|
runtime_gc
|
expert+
|
go
|
Task type: runtime_gc
Scenario: edge sync
Domain focus: cryptography engineering (defensive)
Primary language: go
Difficulty: expert+
Scale/SLO: p99 < 50ms
Component: component_mhthhljn
Constraints: include verification strategy, include failure modes and recovery, assume adversarial inputs; validate everything, avoid data races and undefined behavior, include deterministic replay plan, explicit contracts and invariants, include backward compatibility and migration plan
Assume tight memory budget and cold-start constraints.
Deliverable: Design a GC/runtime component (mark-sweep/arena/RC hybrid); include pause-time strategy and tests.
|
Output: elite engineering answer optimized for correctness, performance, and operability.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Safety: state transitions preserve invariants; no partial commit leaks.
- Liveness: under bounded faults and stable network, progress occurs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
**Failure modes & recovery**
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Property tests against a pure reference model (state machine).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Fuzzing of parsers/framers/validators with corpus seeds.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"go",
"runtime",
"gc"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000056
|
runtime_gc
|
expert
|
go
|
Task type: runtime_gc
Scenario: job scheduler
Domain focus: observability platforms
Primary language: go
Difficulty: expert
Scale/SLO: 10k RPS peak
Component: component_eszkhncs
Constraints: include verification strategy, include deterministic replay plan, assume adversarial inputs; validate everything, include backward compatibility and migration plan, include test vectors and fuzz strategy, include security threat model (defensive only)
Assume crash-only processes; recovery must be deterministic.
Deliverable: Design a GC/runtime component (mark-sweep/arena/RC hybrid); include pause-time strategy and tests.
|
Output: elite engineering answer optimized for correctness, performance, and operability.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Determinism: replay of the same event log yields identical outputs.
- Liveness: under bounded faults and stable network, progress occurs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
**Failure modes & recovery**
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Fuzzing of parsers/framers/validators with corpus seeds.
- Deterministic simulation with fault injection (crash/partition/latency).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"go",
"runtime",
"gc"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000057
|
runtime_gc
|
hard
|
sql
|
Task type: runtime_gc
Scenario: document indexing pipeline
Domain focus: kernel primitives
Primary language: sql
Difficulty: hard
Scale/SLO: p99 < 50ms
Component: component_qtkubmgu
Constraints: include test vectors and fuzz strategy, include security threat model (defensive only), include deterministic replay plan, include performance model and limits, explicit contracts and invariants, avoid data races and undefined behavior, include backward compatibility and migration plan
Assume hostile inputs and targeted abuse patterns.
Deliverable: Design a GC/runtime component (mark-sweep/arena/RC hybrid); include pause-time strategy and tests.
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Safety: state transitions preserve invariants; no partial commit leaks.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Network partition: minority cannot commit; clients receive retriable errors.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Deterministic simulation with fault injection (crash/partition/latency).
- Fuzzing of parsers/framers/validators with corpus seeds.
- Property tests against a pure reference model (state machine).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Hard checks: fault injection tests gate merges; perf thresholds enforced in CI.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"sql",
"runtime",
"gc"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000058
|
lockfree_primitive
|
expert
|
rust
|
Task type: lockfree_primitive
Scenario: real-time notification hub
Domain focus: formal verification
Primary language: rust
Difficulty: expert
Scale/SLO: 99.99% availability
Component: component_zeyckpes
Constraints: include deterministic replay plan, avoid data races and undefined behavior, include failure modes and recovery, assume adversarial inputs; validate everything, explicit contracts and invariants, include security threat model (defensive only), include performance model and limits
Assume schema changes every sprint; must be backward compatible.
Deliverable: Design a lock-free primitive with memory ordering reasoning and stress tests (no UB).
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Safety: state transitions preserve invariants; no partial commit leaks.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Network partition: minority cannot commit; clients receive retriable errors.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Fuzzing of parsers/framers/validators with corpus seeds.
- Property tests against a pure reference model (state machine).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
**Snippet**
```rust
// Skeleton: SPSC ring buffer with acquire/release (outline)
use std::sync::atomic::{AtomicUsize, Ordering};
pub struct Ring<T> {
buf: Vec<std::mem::MaybeUninit<T>>,
head: AtomicUsize,
tail: AtomicUsize,
cap: usize,
}
// Correctness sketch: producer uses Release on tail store, consumer uses Acquire on tail load.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"rust",
"concurrency",
"memory-model"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000059
|
lockfree_primitive
|
expert
|
cpp
|
Task type: lockfree_primitive
Scenario: streaming ETL
Domain focus: secure enclaves (defensive)
Primary language: cpp
Difficulty: expert
Scale/SLO: p99 < 50ms
Component: component_sxgtlmfh
Constraints: include failure modes and recovery, assume adversarial inputs; validate everything, include test vectors and fuzz strategy, include backward compatibility and migration plan, include performance model and limits, avoid data races and undefined behavior, explicit contracts and invariants
Assume tight memory budget and cold-start constraints.
Deliverable: Design a lock-free primitive with memory ordering reasoning and stress tests (no UB).
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Liveness: under bounded faults and stable network, progress occurs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Network partition: minority cannot commit; clients receive retriable errors.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Deterministic simulation with fault injection (crash/partition/latency).
- Property tests against a pure reference model (state machine).
**Snippet**
```rust
// Skeleton: SPSC ring buffer with acquire/release (outline)
use std::sync::atomic::{AtomicUsize, Ordering};
pub struct Ring<T> {
buf: Vec<std::mem::MaybeUninit<T>>,
head: AtomicUsize,
tail: AtomicUsize,
cap: usize,
}
// Correctness sketch: producer uses Release on tail store, consumer uses Acquire on tail load.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"cpp",
"concurrency",
"memory-model"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000060
|
lockfree_primitive
|
expert
|
cpp
|
Task type: lockfree_primitive
Scenario: graph query service
Domain focus: distributed storage
Primary language: cpp
Difficulty: expert
Scale/SLO: 99.99% availability
Component: component_rigkjrvu
Constraints: include test vectors and fuzz strategy, include performance model and limits, include failure modes and recovery, include deterministic replay plan, include verification strategy
Assume tight memory budget and cold-start constraints.
Deliverable: Design a lock-free primitive with memory ordering reasoning and stress tests (no UB).
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Determinism: replay of the same event log yields identical outputs.
- Safety: state transitions preserve invariants; no partial commit leaks.
- Liveness: under bounded faults and stable network, progress occurs.
**Failure modes & recovery**
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Fuzzing of parsers/framers/validators with corpus seeds.
- Deterministic simulation with fault injection (crash/partition/latency).
- Property tests against a pure reference model (state machine).
**Snippet**
```rust
// Skeleton: SPSC ring buffer with acquire/release (outline)
use std::sync::atomic::{AtomicUsize, Ordering};
pub struct Ring<T> {
buf: Vec<std::mem::MaybeUninit<T>>,
head: AtomicUsize,
tail: AtomicUsize,
cap: usize,
}
// Correctness sketch: producer uses Release on tail store, consumer uses Acquire on tail load.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"cpp",
"concurrency",
"memory-model"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000061
|
lockfree_primitive
|
expert
|
rust
|
Task type: lockfree_primitive
Scenario: job scheduler
Domain focus: stream processing
Primary language: rust
Difficulty: expert
Scale/SLO: 10k RPS peak
Component: component_lxcdclvc
Constraints: include security threat model (defensive only), include backward compatibility and migration plan, explicit contracts and invariants, include performance model and limits, include verification strategy
Assume partial data corruption; include scrubbing strategy.
Deliverable: Design a lock-free primitive with memory ordering reasoning and stress tests (no UB).
|
Output: elite engineering answer optimized for correctness, performance, and operability.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Liveness: under bounded faults and stable network, progress occurs.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Property tests against a pure reference model (state machine).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Fuzzing of parsers/framers/validators with corpus seeds.
**Snippet**
```rust
// Skeleton: SPSC ring buffer with acquire/release (outline)
use std::sync::atomic::{AtomicUsize, Ordering};
pub struct Ring<T> {
buf: Vec<std::mem::MaybeUninit<T>>,
head: AtomicUsize,
tail: AtomicUsize,
cap: usize,
}
// Correctness sketch: producer uses Release on tail store, consumer uses Acquire on tail load.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"rust",
"concurrency",
"memory-model"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000062
|
lockfree_primitive
|
hard
|
rust
|
Task type: lockfree_primitive
Scenario: graph query service
Domain focus: high-frequency trading systems (safe engineering)
Primary language: rust
Difficulty: hard
Scale/SLO: multi-region active-active
Component: component_vixroxxs
Constraints: include verification strategy, include security threat model (defensive only), include failure modes and recovery, include test vectors and fuzz strategy, explicit contracts and invariants
Assume crash-only processes; recovery must be deterministic.
Deliverable: Design a lock-free primitive with memory ordering reasoning and stress tests (no UB).
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Determinism: replay of the same event log yields identical outputs.
- Safety: state transitions preserve invariants; no partial commit leaks.
- Liveness: under bounded faults and stable network, progress occurs.
**Failure modes & recovery**
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Property tests against a pure reference model (state machine).
- Deterministic simulation with fault injection (crash/partition/latency).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
**Snippet**
```rust
// Skeleton: SPSC ring buffer with acquire/release (outline)
use std::sync::atomic::{AtomicUsize, Ordering};
pub struct Ring<T> {
buf: Vec<std::mem::MaybeUninit<T>>,
head: AtomicUsize,
tail: AtomicUsize,
cap: usize,
}
// Correctness sketch: producer uses Release on tail store, consumer uses Acquire on tail load.
```
Hard checks: fault injection tests gate merges; perf thresholds enforced in CI.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"rust",
"concurrency",
"memory-model"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000063
|
lockfree_primitive
|
expert+
|
cpp
|
Task type: lockfree_primitive
Scenario: rate limit gateway
Domain focus: formal verification
Primary language: cpp
Difficulty: expert+
Scale/SLO: 1M msgs/min
Component: component_ehewugds
Constraints: include verification strategy, explicit contracts and invariants, include performance model and limits, include deterministic replay plan, include failure modes and recovery, avoid data races and undefined behavior, assume adversarial inputs; validate everything
Assume hostile inputs and targeted abuse patterns.
Deliverable: Design a lock-free primitive with memory ordering reasoning and stress tests (no UB).
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Safety: state transitions preserve invariants; no partial commit leaks.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Network partition: minority cannot commit; clients receive retriable errors.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Property tests against a pure reference model (state machine).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Fuzzing of parsers/framers/validators with corpus seeds.
**Snippet**
```rust
// Skeleton: SPSC ring buffer with acquire/release (outline)
use std::sync::atomic::{AtomicUsize, Ordering};
pub struct Ring<T> {
buf: Vec<std::mem::MaybeUninit<T>>,
head: AtomicUsize,
tail: AtomicUsize,
cap: usize,
}
// Correctness sketch: producer uses Release on tail store, consumer uses Acquire on tail load.
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"cpp",
"concurrency",
"memory-model"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000064
|
kernel_syscall_design
|
expert+
|
c
|
Task type: kernel_syscall_design
Scenario: time-series metrics store
Domain focus: formal verification
Primary language: c
Difficulty: expert+
Scale/SLO: 50 TB/day ingestion
Component: component_topdcbck
Constraints: assume adversarial inputs; validate everything, explicit contracts and invariants, include security threat model (defensive only), include verification strategy, include test vectors and fuzz strategy, avoid data races and undefined behavior
Assume strict auditability and replayable history.
Deliverable: Design a safe syscall/API boundary: ABI, validation, error codes, and compatibility; include tests and fuzz plan.
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Safety: state transitions preserve invariants; no partial commit leaks.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Liveness: under bounded faults and stable network, progress occurs.
**Failure modes & recovery**
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Fuzzing of parsers/framers/validators with corpus seeds.
- Property tests against a pure reference model (state machine).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"c",
"os",
"interfaces"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000065
|
kernel_syscall_design
|
hard
|
cpp
|
Task type: kernel_syscall_design
Scenario: rate limit gateway
Domain focus: kernel primitives
Primary language: cpp
Difficulty: hard
Scale/SLO: 1M msgs/min
Component: component_jdnpdwhh
Constraints: assume adversarial inputs; validate everything, include deterministic replay plan, include backward compatibility and migration plan, explicit contracts and invariants, include verification strategy, include performance model and limits
Assume crash-only processes; recovery must be deterministic.
Deliverable: Design a safe syscall/API boundary: ABI, validation, error codes, and compatibility; include tests and fuzz plan.
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Safety: state transitions preserve invariants; no partial commit leaks.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Liveness: under bounded faults and stable network, progress occurs.
**Failure modes & recovery**
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Network partition: minority cannot commit; clients receive retriable errors.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Fuzzing of parsers/framers/validators with corpus seeds.
- Deterministic simulation with fault injection (crash/partition/latency).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Hard checks: fault injection tests gate merges; perf thresholds enforced in CI.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"cpp",
"os",
"interfaces"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000066
|
kernel_syscall_design
|
hard
|
cpp
|
Task type: kernel_syscall_design
Scenario: multi-tenant event ingestion
Domain focus: secure enclaves (defensive)
Primary language: cpp
Difficulty: hard
Scale/SLO: 100k RPS peak
Component: component_bnwbyuxf
Constraints: include backward compatibility and migration plan, avoid data races and undefined behavior, include deterministic replay plan, include security threat model (defensive only), include verification strategy, explicit contracts and invariants
Assume partial data corruption; include scrubbing strategy.
Deliverable: Design a safe syscall/API boundary: ABI, validation, error codes, and compatibility; include tests and fuzz plan.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Liveness: under bounded faults and stable network, progress occurs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Safety: state transitions preserve invariants; no partial commit leaks.
**Failure modes & recovery**
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Property tests against a pure reference model (state machine).
- Fuzzing of parsers/framers/validators with corpus seeds.
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Hard checks: fault injection tests gate merges; perf thresholds enforced in CI.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"cpp",
"os",
"interfaces"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000067
|
kernel_syscall_design
|
expert
|
rust
|
Task type: kernel_syscall_design
Scenario: job scheduler
Domain focus: static analysis
Primary language: rust
Difficulty: expert
Scale/SLO: 50 TB/day ingestion
Component: component_awpuwscf
Constraints: include failure modes and recovery, avoid data races and undefined behavior, include deterministic replay plan, explicit contracts and invariants, include verification strategy
Assume partial data corruption; include scrubbing strategy.
Deliverable: Design a safe syscall/API boundary: ABI, validation, error codes, and compatibility; include tests and fuzz plan.
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Safety: state transitions preserve invariants; no partial commit leaks.
- Liveness: under bounded faults and stable network, progress occurs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
**Failure modes & recovery**
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Deterministic simulation with fault injection (crash/partition/latency).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Property tests against a pure reference model (state machine).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"rust",
"os",
"interfaces"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000068
|
network_protocol
|
expert
|
go
|
Task type: network_protocol
Scenario: graph query service
Domain focus: constraint solving
Primary language: go
Difficulty: expert
Scale/SLO: p99 < 50ms
Component: component_japcufpe
Constraints: include verification strategy, include backward compatibility and migration plan, include performance model and limits, assume adversarial inputs; validate everything, avoid data races and undefined behavior, explicit contracts and invariants
Assume partial data corruption; include scrubbing strategy.
Deliverable: Design an application protocol: framing, retries, backpressure, timeouts; include client/server skeleton and test vectors.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Safety: state transitions preserve invariants; no partial commit leaks.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Deterministic simulation with fault injection (crash/partition/latency).
- Property tests against a pure reference model (state machine).
- Fuzzing of parsers/framers/validators with corpus seeds.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"go",
"protocols",
"reliability"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000069
|
network_protocol
|
hard
|
typescript
|
Task type: network_protocol
Scenario: identity and access
Domain focus: static analysis
Primary language: typescript
Difficulty: hard
Scale/SLO: 10k RPS peak
Component: component_pzeqknba
Constraints: include deterministic replay plan, avoid data races and undefined behavior, include backward compatibility and migration plan, include failure modes and recovery, include verification strategy, include performance model and limits
Assume partial data corruption; include scrubbing strategy.
Deliverable: Design an application protocol: framing, retries, backpressure, timeouts; include client/server skeleton and test vectors.
|
Output: elite engineering answer optimized for correctness, performance, and operability.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Determinism: replay of the same event log yields identical outputs.
- Safety: state transitions preserve invariants; no partial commit leaks.
- Liveness: under bounded faults and stable network, progress occurs.
**Failure modes & recovery**
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Deterministic simulation with fault injection (crash/partition/latency).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Property tests against a pure reference model (state machine).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Hard checks: fault injection tests gate merges; perf thresholds enforced in CI.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"typescript",
"protocols",
"reliability"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000070
|
network_protocol
|
hard
|
bash
|
Task type: network_protocol
Scenario: real-time notification hub
Domain focus: constraint solving
Primary language: bash
Difficulty: hard
Scale/SLO: 10k RPS peak
Component: component_muwtlsyh
Constraints: include deterministic replay plan, include performance model and limits, avoid data races and undefined behavior, include verification strategy, include security threat model (defensive only)
Assume tight memory budget and cold-start constraints.
Deliverable: Design an application protocol: framing, retries, backpressure, timeouts; include client/server skeleton and test vectors.
|
Output: elite engineering answer optimized for correctness, performance, and operability.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Safety: state transitions preserve invariants; no partial commit leaks.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Network partition: minority cannot commit; clients receive retriable errors.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Deterministic simulation with fault injection (crash/partition/latency).
- Fuzzing of parsers/framers/validators with corpus seeds.
- Property tests against a pure reference model (state machine).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Hard checks: fault injection tests gate merges; perf thresholds enforced in CI.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"bash",
"protocols",
"reliability"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000071
|
network_protocol
|
expert+
|
typescript
|
Task type: network_protocol
Scenario: edge sync
Domain focus: formal verification
Primary language: typescript
Difficulty: expert+
Scale/SLO: 10k RPS peak
Component: component_bqmboovr
Constraints: include backward compatibility and migration plan, include failure modes and recovery, avoid data races and undefined behavior, include deterministic replay plan, include security threat model (defensive only)
Assume crash-only processes; recovery must be deterministic.
Deliverable: Design an application protocol: framing, retries, backpressure, timeouts; include client/server skeleton and test vectors.
|
Output: elite engineering answer optimized for correctness, performance, and operability.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Liveness: under bounded faults and stable network, progress occurs.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Fuzzing of parsers/framers/validators with corpus seeds.
- Deterministic simulation with fault injection (crash/partition/latency).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"typescript",
"protocols",
"reliability"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000072
|
network_protocol
|
expert
|
bash
|
Task type: network_protocol
Scenario: identity and access
Domain focus: network protocols
Primary language: bash
Difficulty: expert
Scale/SLO: 100k RPS peak
Component: component_qslvkntc
Constraints: include performance model and limits, include deterministic replay plan, include failure modes and recovery, include test vectors and fuzz strategy, include verification strategy, explicit contracts and invariants
Assume strict auditability and replayable history.
Deliverable: Design an application protocol: framing, retries, backpressure, timeouts; include client/server skeleton and test vectors.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Determinism: replay of the same event log yields identical outputs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Safety: state transitions preserve invariants; no partial commit leaks.
**Failure modes & recovery**
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Fuzzing of parsers/framers/validators with corpus seeds.
- Property tests against a pure reference model (state machine).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"bash",
"protocols",
"reliability"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000073
|
network_protocol
|
expert+
|
bash
|
Task type: network_protocol
Scenario: job scheduler
Domain focus: large-scale ML systems
Primary language: bash
Difficulty: expert+
Scale/SLO: 1M msgs/min
Component: component_mwrbpxmt
Constraints: assume adversarial inputs; validate everything, include failure modes and recovery, include security threat model (defensive only), include backward compatibility and migration plan, include deterministic replay plan, include test vectors and fuzz strategy
Assume schema changes every sprint; must be backward compatible.
Deliverable: Design an application protocol: framing, retries, backpressure, timeouts; include client/server skeleton and test vectors.
|
Output: elite engineering answer optimized for correctness, performance, and operability.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Liveness: under bounded faults and stable network, progress occurs.
- Determinism: replay of the same event log yields identical outputs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
**Failure modes & recovery**
- Network partition: minority cannot commit; clients receive retriable errors.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Property tests against a pure reference model (state machine).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Deterministic simulation with fault injection (crash/partition/latency).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"bash",
"protocols",
"reliability"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000074
|
secure_architecture
|
hard
|
typescript
|
Task type: secure_architecture
Scenario: real-time notification hub
Domain focus: edge robotics (safe)
Primary language: typescript
Difficulty: hard
Scale/SLO: multi-region active-active
Component: component_ejmbatkz
Constraints: include backward compatibility and migration plan, avoid data races and undefined behavior, explicit contracts and invariants, assume adversarial inputs; validate everything, include performance model and limits
Assume weekly network partitions.
Deliverable: Provide a defensive threat model and secure-by-default architecture; include monitoring/detection and tests (no offensive content).
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Liveness: under bounded faults and stable network, progress occurs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Safety: state transitions preserve invariants; no partial commit leaks.
**Failure modes & recovery**
- Network partition: minority cannot commit; clients receive retriable errors.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Deterministic simulation with fault injection (crash/partition/latency).
- Fuzzing of parsers/framers/validators with corpus seeds.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Hard checks: fault injection tests gate merges; perf thresholds enforced in CI.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"typescript",
"security",
"threat-modeling"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000075
|
secure_architecture
|
expert
|
sql
|
Task type: secure_architecture
Scenario: rate limit gateway
Domain focus: static analysis
Primary language: sql
Difficulty: expert
Scale/SLO: 100k RPS peak
Component: component_jmlpcrdi
Constraints: include backward compatibility and migration plan, include deterministic replay plan, assume adversarial inputs; validate everything, include security threat model (defensive only), include failure modes and recovery, explicit contracts and invariants
Assume partial data corruption; include scrubbing strategy.
Deliverable: Provide a defensive threat model and secure-by-default architecture; include monitoring/detection and tests (no offensive content).
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Safety: state transitions preserve invariants; no partial commit leaks.
- Liveness: under bounded faults and stable network, progress occurs.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Network partition: minority cannot commit; clients receive retriable errors.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Property tests against a pure reference model (state machine).
- Fuzzing of parsers/framers/validators with corpus seeds.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"sql",
"security",
"threat-modeling"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000076
|
secure_architecture
|
expert
|
rust
|
Task type: secure_architecture
Scenario: job scheduler
Domain focus: high-frequency trading systems (safe engineering)
Primary language: rust
Difficulty: expert
Scale/SLO: multi-region active-active
Component: component_zbwncurp
Constraints: include test vectors and fuzz strategy, assume adversarial inputs; validate everything, include backward compatibility and migration plan, include performance model and limits, explicit contracts and invariants
Assume hostile inputs and targeted abuse patterns.
Deliverable: Provide a defensive threat model and secure-by-default architecture; include monitoring/detection and tests (no offensive content).
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Safety: state transitions preserve invariants; no partial commit leaks.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Network partition: minority cannot commit; clients receive retriable errors.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Fuzzing of parsers/framers/validators with corpus seeds.
- Deterministic simulation with fault injection (crash/partition/latency).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"rust",
"security",
"threat-modeling"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000077
|
secure_architecture
|
expert
|
sql
|
Task type: secure_architecture
Scenario: job scheduler
Domain focus: data lineage & governance
Primary language: sql
Difficulty: expert
Scale/SLO: 50 TB/day ingestion
Component: component_ucxgayzs
Constraints: assume adversarial inputs; validate everything, include failure modes and recovery, explicit contracts and invariants, include security threat model (defensive only), avoid data races and undefined behavior, include performance model and limits, include backward compatibility and migration plan
Assume crash-only processes; recovery must be deterministic.
Deliverable: Provide a defensive threat model and secure-by-default architecture; include monitoring/detection and tests (no offensive content).
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Determinism: replay of the same event log yields identical outputs.
- Safety: state transitions preserve invariants; no partial commit leaks.
- Liveness: under bounded faults and stable network, progress occurs.
**Failure modes & recovery**
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Network partition: minority cannot commit; clients receive retriable errors.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Property tests against a pure reference model (state machine).
- Deterministic simulation with fault injection (crash/partition/latency).
- Fuzzing of parsers/framers/validators with corpus seeds.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"sql",
"security",
"threat-modeling"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000078
|
secure_architecture
|
expert
|
python
|
Task type: secure_architecture
Scenario: rate limit gateway
Domain focus: query planning
Primary language: python
Difficulty: expert
Scale/SLO: 10k RPS peak
Component: component_vagexgdf
Constraints: include verification strategy, explicit contracts and invariants, include test vectors and fuzz strategy, include backward compatibility and migration plan, include performance model and limits
Assume partial data corruption; include scrubbing strategy.
Deliverable: Provide a defensive threat model and secure-by-default architecture; include monitoring/detection and tests (no offensive content).
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Liveness: under bounded faults and stable network, progress occurs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Network partition: minority cannot commit; clients receive retriable errors.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Deterministic simulation with fault injection (crash/partition/latency).
- Fuzzing of parsers/framers/validators with corpus seeds.
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"python",
"security",
"threat-modeling"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000079
|
secure_architecture
|
hard
|
typescript
|
Task type: secure_architecture
Scenario: identity and access
Domain focus: zero-downtime migrations
Primary language: typescript
Difficulty: hard
Scale/SLO: 50 TB/day ingestion
Component: component_heogfkas
Constraints: include performance model and limits, include backward compatibility and migration plan, avoid data races and undefined behavior, include verification strategy, explicit contracts and invariants
Assume weekly network partitions.
Deliverable: Provide a defensive threat model and secure-by-default architecture; include monitoring/detection and tests (no offensive content).
|
Output: elite engineering answer optimized for correctness, performance, and operability.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Determinism: replay of the same event log yields identical outputs.
- Liveness: under bounded faults and stable network, progress occurs.
**Failure modes & recovery**
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Network partition: minority cannot commit; clients receive retriable errors.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Fuzzing of parsers/framers/validators with corpus seeds.
- Deterministic simulation with fault injection (crash/partition/latency).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Hard checks: fault injection tests gate merges; perf thresholds enforced in CI.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"typescript",
"security",
"threat-modeling"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000080
|
supply_chain_security
|
expert
|
bash
|
Task type: supply_chain_security
Scenario: streaming ETL
Domain focus: real-time scheduling
Primary language: bash
Difficulty: expert
Scale/SLO: 1M msgs/min
Component: component_bzrrptoo
Constraints: include backward compatibility and migration plan, include test vectors and fuzz strategy, include deterministic replay plan, assume adversarial inputs; validate everything, explicit contracts and invariants, include security threat model (defensive only)
Assume hostile inputs and targeted abuse patterns.
Deliverable: Design a supply-chain security plan: SBOM, signing, provenance, dependency policy, and CI gates.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Safety: state transitions preserve invariants; no partial commit leaks.
- Liveness: under bounded faults and stable network, progress occurs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
**Failure modes & recovery**
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Property tests against a pure reference model (state machine).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Fuzzing of parsers/framers/validators with corpus seeds.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"bash",
"sbom",
"signing"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000081
|
supply_chain_security
|
hard
|
typescript
|
Task type: supply_chain_security
Scenario: feature-flag evaluation
Domain focus: secure enclaves (defensive)
Primary language: typescript
Difficulty: hard
Scale/SLO: p99 < 150ms
Component: component_khdykpyw
Constraints: include backward compatibility and migration plan, include deterministic replay plan, include security threat model (defensive only), include performance model and limits, include test vectors and fuzz strategy, include verification strategy, include failure modes and recovery
Assume schema changes every sprint; must be backward compatible.
Deliverable: Design a supply-chain security plan: SBOM, signing, provenance, dependency policy, and CI gates.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Determinism: replay of the same event log yields identical outputs.
- Safety: state transitions preserve invariants; no partial commit leaks.
**Failure modes & recovery**
- Network partition: minority cannot commit; clients receive retriable errors.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Deterministic simulation with fault injection (crash/partition/latency).
- Fuzzing of parsers/framers/validators with corpus seeds.
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Hard checks: fault injection tests gate merges; perf thresholds enforced in CI.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"typescript",
"sbom",
"signing"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000082
|
supply_chain_security
|
hard
|
bash
|
Task type: supply_chain_security
Scenario: feature-flag evaluation
Domain focus: network protocols
Primary language: bash
Difficulty: hard
Scale/SLO: multi-region active-active
Component: component_guvxupfr
Constraints: include deterministic replay plan, include security threat model (defensive only), assume adversarial inputs; validate everything, include performance model and limits, avoid data races and undefined behavior, include failure modes and recovery
Assume crash-only processes; recovery must be deterministic.
Deliverable: Design a supply-chain security plan: SBOM, signing, provenance, dependency policy, and CI gates.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Liveness: under bounded faults and stable network, progress occurs.
- Determinism: replay of the same event log yields identical outputs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
**Failure modes & recovery**
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Deterministic simulation with fault injection (crash/partition/latency).
- Fuzzing of parsers/framers/validators with corpus seeds.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Hard checks: fault injection tests gate merges; perf thresholds enforced in CI.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"bash",
"sbom",
"signing"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000083
|
sre_incident_sim
|
expert
|
bash
|
Task type: sre_incident_sim
Scenario: time-series metrics store
Domain focus: observability platforms
Primary language: bash
Difficulty: expert
Scale/SLO: 50 TB/day ingestion
Component: component_ahfaqbhk
Constraints: include backward compatibility and migration plan, explicit contracts and invariants, include security threat model (defensive only), include verification strategy, include performance model and limits, include deterministic replay plan
Assume tight memory budget and cold-start constraints.
Deliverable: Provide incident simulation: SLOs, alerts, runbooks, and game-day plan; include postmortem template.
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Liveness: under bounded faults and stable network, progress occurs.
- Safety: state transitions preserve invariants; no partial commit leaks.
**Failure modes & recovery**
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Fuzzing of parsers/framers/validators with corpus seeds.
- Property tests against a pure reference model (state machine).
- Deterministic simulation with fault injection (crash/partition/latency).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"bash",
"sre",
"runbooks"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000084
|
sre_incident_sim
|
expert+
|
typescript
|
Task type: sre_incident_sim
Scenario: identity and access
Domain focus: query planning
Primary language: typescript
Difficulty: expert+
Scale/SLO: 100k RPS peak
Component: component_vdxbxeup
Constraints: include performance model and limits, include verification strategy, include deterministic replay plan, avoid data races and undefined behavior, explicit contracts and invariants, include security threat model (defensive only)
Assume partial data corruption; include scrubbing strategy.
Deliverable: Provide incident simulation: SLOs, alerts, runbooks, and game-day plan; include postmortem template.
|
Output: elite engineering answer optimized for correctness, performance, and operability.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Determinism: replay of the same event log yields identical outputs.
- Safety: state transitions preserve invariants; no partial commit leaks.
- Liveness: under bounded faults and stable network, progress occurs.
**Failure modes & recovery**
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Deterministic simulation with fault injection (crash/partition/latency).
- Property tests against a pure reference model (state machine).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"typescript",
"sre",
"runbooks"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000085
|
sre_incident_sim
|
expert
|
go
|
Task type: sre_incident_sim
Scenario: rate limit gateway
Domain focus: runtime systems
Primary language: go
Difficulty: expert
Scale/SLO: 10k RPS peak
Component: component_luvkgsss
Constraints: include test vectors and fuzz strategy, include backward compatibility and migration plan, include security threat model (defensive only), avoid data races and undefined behavior, explicit contracts and invariants
Assume hostile inputs and targeted abuse patterns.
Deliverable: Provide incident simulation: SLOs, alerts, runbooks, and game-day plan; include postmortem template.
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Safety: state transitions preserve invariants; no partial commit leaks.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Liveness: under bounded faults and stable network, progress occurs.
**Failure modes & recovery**
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Network partition: minority cannot commit; clients receive retriable errors.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Property tests against a pure reference model (state machine).
- Deterministic simulation with fault injection (crash/partition/latency).
- Fuzzing of parsers/framers/validators with corpus seeds.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"go",
"sre",
"runbooks"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000086
|
perf_microarchitecture
|
expert+
|
rust
|
Task type: perf_microarchitecture
Scenario: job scheduler
Domain focus: high-frequency trading systems (safe engineering)
Primary language: rust
Difficulty: expert+
Scale/SLO: 1M msgs/min
Component: component_knvsalkb
Constraints: include backward compatibility and migration plan, avoid data races and undefined behavior, include performance model and limits, include verification strategy, include deterministic replay plan
Assume hostile inputs and targeted abuse patterns.
Deliverable: Provide performance engineering plan: profiling, hot-path redesign, cache behavior assumptions, and microbench harness.
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Safety: state transitions preserve invariants; no partial commit leaks.
- Liveness: under bounded faults and stable network, progress occurs.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Network partition: minority cannot commit; clients receive retriable errors.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Fuzzing of parsers/framers/validators with corpus seeds.
- Property tests against a pure reference model (state machine).
- Deterministic simulation with fault injection (crash/partition/latency).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"rust",
"performance",
"profiling"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000087
|
perf_microarchitecture
|
expert
|
go
|
Task type: perf_microarchitecture
Scenario: payment ledger
Domain focus: zero-downtime migrations
Primary language: go
Difficulty: expert
Scale/SLO: p99 < 150ms
Component: component_kjqaqcau
Constraints: assume adversarial inputs; validate everything, include test vectors and fuzz strategy, include verification strategy, include backward compatibility and migration plan, include failure modes and recovery, include security threat model (defensive only)
Assume tight memory budget and cold-start constraints.
Deliverable: Provide performance engineering plan: profiling, hot-path redesign, cache behavior assumptions, and microbench harness.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Liveness: under bounded faults and stable network, progress occurs.
- Safety: state transitions preserve invariants; no partial commit leaks.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Property tests against a pure reference model (state machine).
- Deterministic simulation with fault injection (crash/partition/latency).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"go",
"performance",
"profiling"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000088
|
perf_microarchitecture
|
expert
|
sql
|
Task type: perf_microarchitecture
Scenario: multi-tenant event ingestion
Domain focus: compiler toolchains
Primary language: sql
Difficulty: expert
Scale/SLO: multi-region active-active
Component: component_tdjeylch
Constraints: include performance model and limits, include failure modes and recovery, assume adversarial inputs; validate everything, avoid data races and undefined behavior, explicit contracts and invariants, include verification strategy, include test vectors and fuzz strategy
Assume partial data corruption; include scrubbing strategy.
Deliverable: Provide performance engineering plan: profiling, hot-path redesign, cache behavior assumptions, and microbench harness.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Safety: state transitions preserve invariants; no partial commit leaks.
- Liveness: under bounded faults and stable network, progress occurs.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Deterministic simulation with fault injection (crash/partition/latency).
- Property tests against a pure reference model (state machine).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"sql",
"performance",
"profiling"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000089
|
gpu_serving_pipeline
|
expert+
|
python
|
Task type: gpu_serving_pipeline
Scenario: real-time notification hub
Domain focus: cryptography engineering (defensive)
Primary language: python
Difficulty: expert+
Scale/SLO: 1M msgs/min
Component: component_sgjsvaia
Constraints: assume adversarial inputs; validate everything, include backward compatibility and migration plan, include security threat model (defensive only), explicit contracts and invariants, avoid data races and undefined behavior, include verification strategy, include performance model and limits
Assume partial data corruption; include scrubbing strategy.
Deliverable: Design a GPU inference serving pipeline: batching, scheduling, memory management, tail-latency control, and monitoring.
|
Output: elite engineering answer optimized for correctness, performance, and operability.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Liveness: under bounded faults and stable network, progress occurs.
- Safety: state transitions preserve invariants; no partial commit leaks.
**Failure modes & recovery**
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Fuzzing of parsers/framers/validators with corpus seeds.
- Property tests against a pure reference model (state machine).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"python",
"gpu",
"throughput"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000090
|
gpu_serving_pipeline
|
expert
|
bash
|
Task type: gpu_serving_pipeline
Scenario: payment ledger
Domain focus: GPU serving
Primary language: bash
Difficulty: expert
Scale/SLO: 50 TB/day ingestion
Component: component_vnaxscqa
Constraints: include security threat model (defensive only), explicit contracts and invariants, include failure modes and recovery, include verification strategy, assume adversarial inputs; validate everything
Assume schema changes every sprint; must be backward compatible.
Deliverable: Design a GPU inference serving pipeline: batching, scheduling, memory management, tail-latency control, and monitoring.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Liveness: under bounded faults and stable network, progress occurs.
- Safety: state transitions preserve invariants; no partial commit leaks.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
**Failure modes & recovery**
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Network partition: minority cannot commit; clients receive retriable errors.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Property tests against a pure reference model (state machine).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Fuzzing of parsers/framers/validators with corpus seeds.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"bash",
"gpu",
"throughput"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000091
|
gpu_serving_pipeline
|
expert
|
sql
|
Task type: gpu_serving_pipeline
Scenario: real-time notification hub
Domain focus: query planning
Primary language: sql
Difficulty: expert
Scale/SLO: 100k RPS peak
Component: component_irjvmdpo
Constraints: include security threat model (defensive only), avoid data races and undefined behavior, include performance model and limits, include test vectors and fuzz strategy, include backward compatibility and migration plan, explicit contracts and invariants
Assume crash-only processes; recovery must be deterministic.
Deliverable: Design a GPU inference serving pipeline: batching, scheduling, memory management, tail-latency control, and monitoring.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Determinism: replay of the same event log yields identical outputs.
- Safety: state transitions preserve invariants; no partial commit leaks.
- Liveness: under bounded faults and stable network, progress occurs.
**Failure modes & recovery**
- Network partition: minority cannot commit; clients receive retriable errors.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Fuzzing of parsers/framers/validators with corpus seeds.
- Property tests against a pure reference model (state machine).
- Deterministic simulation with fault injection (crash/partition/latency).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"sql",
"gpu",
"throughput"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000092
|
ml_system_design
|
expert+
|
sql
|
Task type: ml_system_design
Scenario: rate limit gateway
Domain focus: static analysis
Primary language: sql
Difficulty: expert+
Scale/SLO: p99 < 150ms
Component: component_xysnveas
Constraints: assume adversarial inputs; validate everything, avoid data races and undefined behavior, include verification strategy, include test vectors and fuzz strategy, include failure modes and recovery
Assume hostile inputs and targeted abuse patterns.
Deliverable: Design end-to-end ML system: data contracts, training, evaluation, registry, serving, monitoring, and rollback.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Liveness: under bounded faults and stable network, progress occurs.
- Safety: state transitions preserve invariants; no partial commit leaks.
**Failure modes & recovery**
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Property tests against a pure reference model (state machine).
- Fuzzing of parsers/framers/validators with corpus seeds.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"sql",
"mlops",
"serving"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000093
|
ml_system_design
|
expert+
|
python
|
Task type: ml_system_design
Scenario: feature-flag evaluation
Domain focus: network protocols
Primary language: python
Difficulty: expert+
Scale/SLO: p99 < 150ms
Component: component_mrozzamy
Constraints: include test vectors and fuzz strategy, explicit contracts and invariants, include backward compatibility and migration plan, include performance model and limits, include failure modes and recovery, include verification strategy, include deterministic replay plan
Assume tight memory budget and cold-start constraints.
Deliverable: Design end-to-end ML system: data contracts, training, evaluation, registry, serving, monitoring, and rollback.
|
Output: rigorous design + invariants + verification plan + implementation sketch.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Liveness: under bounded faults and stable network, progress occurs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Network partition: minority cannot commit; clients receive retriable errors.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Fuzzing of parsers/framers/validators with corpus seeds.
- Property tests against a pure reference model (state machine).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"python",
"mlops",
"serving"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000094
|
robust_e2e_testing
|
expert
|
go
|
Task type: robust_e2e_testing
Scenario: edge sync
Domain focus: fault injection & chaos engineering
Primary language: go
Difficulty: expert
Scale/SLO: multi-region active-active
Component: component_rkixekyv
Constraints: explicit contracts and invariants, include test vectors and fuzz strategy, include performance model and limits, assume adversarial inputs; validate everything, include security threat model (defensive only), include verification strategy, include backward compatibility and migration plan
Assume weekly network partitions.
Deliverable: Design an E2E testing strategy with determinism, fuzzing, chaos, and CI gating.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Safety: state transitions preserve invariants; no partial commit leaks.
- Liveness: under bounded faults and stable network, progress occurs.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Fuzzing of parsers/framers/validators with corpus seeds.
- Property tests against a pure reference model (state machine).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"go",
"testing",
"fuzzing"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000095
|
robust_e2e_testing
|
expert+
|
rust
|
Task type: robust_e2e_testing
Scenario: identity and access
Domain focus: formal verification
Primary language: rust
Difficulty: expert+
Scale/SLO: p99 < 150ms
Component: component_darieaos
Constraints: assume adversarial inputs; validate everything, include deterministic replay plan, include backward compatibility and migration plan, include test vectors and fuzz strategy, explicit contracts and invariants
Assume schema changes every sprint; must be backward compatible.
Deliverable: Design an E2E testing strategy with determinism, fuzzing, chaos, and CI gating.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Determinism: replay of the same event log yields identical outputs.
- Safety: state transitions preserve invariants; no partial commit leaks.
**Failure modes & recovery**
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Network partition: minority cannot commit; clients receive retriable errors.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Fuzzing of parsers/framers/validators with corpus seeds.
- Property tests against a pure reference model (state machine).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"rust",
"testing",
"fuzzing"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000096
|
schema_evolution_contracts
|
expert
|
rust
|
Task type: schema_evolution_contracts
Scenario: document indexing pipeline
Domain focus: model checking
Primary language: rust
Difficulty: expert
Scale/SLO: 10k RPS peak
Component: component_carhludu
Constraints: assume adversarial inputs; validate everything, include performance model and limits, include verification strategy, explicit contracts and invariants, include security threat model (defensive only), include backward compatibility and migration plan, include deterministic replay plan
Assume crash-only processes; recovery must be deterministic.
Deliverable: Design schema evolution rules and compatibility tests; include migration plan and examples.
|
Output: elite engineering answer optimized for correctness, performance, and operability.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Safety: state transitions preserve invariants; no partial commit leaks.
- Determinism: replay of the same event log yields identical outputs.
- Liveness: under bounded faults and stable network, progress occurs.
**Failure modes & recovery**
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Fuzzing of parsers/framers/validators with corpus seeds.
- Deterministic simulation with fault injection (crash/partition/latency).
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert checks: state-machine proof sketch + model checking; upgrade/rollback rehearsed.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"rust",
"schemas",
"compat"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000097
|
program_synthesis_safe
|
expert+
|
typescript
|
Task type: program_synthesis_safe
Scenario: payment ledger
Domain focus: consensus & replication
Primary language: typescript
Difficulty: expert+
Scale/SLO: 99.99% availability
Component: component_ncgrezyp
Constraints: include backward compatibility and migration plan, include verification strategy, include deterministic replay plan, avoid data races and undefined behavior, include performance model and limits, explicit contracts and invariants, include security threat model (defensive only)
Assume hostile inputs and targeted abuse patterns.
Deliverable: Design a program-synthesis workflow that generates code from specs safely; include guardrails and verification.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Safety: state transitions preserve invariants; no partial commit leaks.
- Determinism: replay of the same event log yields identical outputs.
- Liveness: under bounded faults and stable network, progress occurs.
**Failure modes & recovery**
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Network partition: minority cannot commit; clients receive retriable errors.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Deterministic simulation with fault injection (crash/partition/latency).
- Property tests against a pure reference model (state machine).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"typescript",
"synthesis",
"specs"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000098
|
formal_proof_sketch
|
hard
|
sql
|
Task type: formal_proof_sketch
Scenario: streaming ETL
Domain focus: large-scale ML systems
Primary language: sql
Difficulty: hard
Scale/SLO: p99 < 150ms
Component: component_nfjkoqxs
Constraints: include deterministic replay plan, include verification strategy, include failure modes and recovery, include security threat model (defensive only), explicit contracts and invariants, assume adversarial inputs; validate everything, avoid data races and undefined behavior
Assume strict auditability and replayable history.
Deliverable: Provide a rigorous proof sketch for key invariants and show how to test/verify them in practice.
|
Output: elite engineering answer optimized for correctness, performance, and operability.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Liveness: under bounded faults and stable network, progress occurs.
- Determinism: replay of the same event log yields identical outputs.
- Safety: state transitions preserve invariants; no partial commit leaks.
**Failure modes & recovery**
- Network partition: minority cannot commit; clients receive retriable errors.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Property tests against a pure reference model (state machine).
- Fuzzing of parsers/framers/validators with corpus seeds.
- Deterministic simulation with fault injection (crash/partition/latency).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Hard checks: fault injection tests gate merges; perf thresholds enforced in CI.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"sql",
"proofs",
"invariants"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000099
|
verification_properties
|
hard
|
typescript
|
Task type: verification_properties
Scenario: graph query service
Domain focus: network protocols
Primary language: typescript
Difficulty: hard
Scale/SLO: 50 TB/day ingestion
Component: component_oigdigie
Constraints: avoid data races and undefined behavior, include security threat model (defensive only), include performance model and limits, explicit contracts and invariants, include failure modes and recovery
Assume crash-only processes; recovery must be deterministic.
Deliverable: Define properties and provide property-based/generative test plan with a reference model.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Liveness: under bounded faults and stable network, progress occurs.
- Safety: state transitions preserve invariants; no partial commit leaks.
- Determinism: replay of the same event log yields identical outputs.
**Failure modes & recovery**
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
- Network partition: minority cannot commit; clients receive retriable errors.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Deterministic simulation with fault injection (crash/partition/latency).
- Fuzzing of parsers/framers/validators with corpus seeds.
- Property tests against a pure reference model (state machine).
**Snippet**
```text
Implementation sketch: factor pure state-machine core; adapters for I/O; add deterministic replay log.
```
Hard checks: fault injection tests gate merges; perf thresholds enforced in CI.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"typescript",
"property-based",
"verification"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
omega_000100
|
mechanized_spec
|
expert+
|
lean
|
Task type: mechanized_spec
Scenario: identity and access
Domain focus: query planning
Primary language: lean
Difficulty: expert+
Scale/SLO: 10k RPS peak
Component: component_tbtbjfhx
Constraints: include performance model and limits, include failure modes and recovery, include test vectors and fuzz strategy, explicit contracts and invariants, include verification strategy, avoid data races and undefined behavior
Assume weekly network partitions.
Deliverable: Provide a mechanized-style spec outline (Lean-like), key definitions, and a proof plan. Include executable reference code skeleton and tests.
|
Output: contract-first solution with failure modes, security posture, and test/verification strategy.
**Contract**
- Inputs validated at the boundary; explicit error taxonomy.
- Idempotency for side effects via request_id; deterministic replay.
- Backward compatibility: additive changes by default; versioned breaking changes.
**Invariants**
- Liveness: under bounded faults and stable network, progress occurs.
- Isolation: tenant boundary enforced; no cross-tenant reads/writes.
- Safety: state transitions preserve invariants; no partial commit leaks.
**Failure modes & recovery**
- Data corruption: checksums + scrubber; quarantine and rebuild from replicas/snapshots.
- Crash during commit: WAL replay completes or transaction aborts; no torn writes.
- Duplicate requests: de-duplicate by (tenant, request_id) returning cached response.
**Security posture (defensive)**
- Threat model: auth/authz, injection, replay/abuse, supply chain.
- Least privilege; secrets in managed store; audit logs for sensitive ops.
- Input normalization, parameterized queries, path traversal protections.
**Verification strategy**
- Canary + shadow traffic; invariants checked in production via assertions/metrics.
- Fuzzing of parsers/framers/validators with corpus seeds.
- Deterministic simulation with fault injection (crash/partition/latency).
**Snippet**
```lean
-- Pseudo-Lean outline
structure State where
ver : Nat
val : Option ByteArray
def invariant (s : State) : Prop := True
theorem step_preserves_invariant :
∀ s, invariant s → ∀ s', Step s s' → invariant s' := by
intro s hs s' hstep
-- proof plan: case analysis on transition; trivial here
trivial
```
Expert+ checks: mechanized invariants (or exhaustive model checking), adversarial fuzzing, and multi-region failure drills.
|
{
"tags": [
"omegagenesis",
"ultra-elite",
"software-engineering",
"lean",
"formal-methods",
"theorem-proving"
],
"has_code": true,
"requires_thinking": true,
"seed": 271828
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.