@o-lang/resolver-tests 1.0.3 → 1.0.5

package/R-006-resolver-runtime-shape/test.json

@@ -0,0 +1,22 @@
+{
+  "test_id": "R-006-runtime-shape",
+  "protocol_version": "1.1",
+  "category": "resolver-runtime",
+  "description": "Ensures resolver exports a callable function.",
+  "spec_ref": ["§4.1 Resolver Runtime Interface"],
+  "fixtures": {
+    "inputs": [
+      {
+        "invoke": {}
+      }
+    ]
+  },
+  "assertions": [
+    {
+      "id": "resolver_is_function",
+      "type": "resolver_is_callable",
+      "severity": "fatal",
+      "description": "Resolver must be a callable function"
+    }
+  ]
+}

package/R-007-resolver-failure-contract/test.json

@@ -0,0 +1,22 @@
+{
+  "test_id": "R-007-failure-contract",
+  "protocol_version": "1.1",
+  "category": "resolver-runtime",
+  "description": "Ensures any thrown failure code is declared in the resolver's failure contract.",
+  "spec_ref": ["§4.4 Resolver Failure Modes"],
+  "fixtures": {
+    "inputs": [
+      {
+        "invoke": {}
+      }
+    ]
+  },
+  "assertions": [
+    {
+      "id": "failure_code_declared",
+      "type": "resolver_failure_declared",
+      "severity": "fatal",
+      "description": "Any error code thrown by the resolver must be listed in its failures[] declaration"
+    }
+  ]
+}

package/R-008-resolver-input-validation/test.json

@@ -0,0 +1,22 @@
+{
+  "test_id": "R-008-input-validation",
+  "protocol_version": "1.1",
+  "category": "resolver-runtime",
+  "description": "Ensures resolver rejects invocations missing required inputs.",
+  "spec_ref": ["§4.2 Resolver Input Contracts"],
+  "fixtures": {
+    "inputs": [
+      {
+        "invoke": {}
+      }
+    ]
+  },
+  "assertions": [
+    {
+      "id": "missing_required_input_rejected",
+      "type": "rejects_missing_required_input",
+      "severity": "fatal",
+      "description": "Resolver must fail when a required input is omitted"
+    }
+  ]
+}

package/R-009-retry-semantics/test.json

@@ -0,0 +1,22 @@
+{
+  "test_id": "R-009-retry-semantics",
+  "protocol_version": "1.1",
+  "category": "resolver-runtime",
+  "description": "Ensures resolver retry behavior does not exceed declared retry limits when failures occur.",
+  "spec_ref": ["§4.4 Resolver Failure Modes"],
+  "fixtures": {
+    "inputs": [
+      {
+        "invoke": {}
+      }
+    ]
+  },
+  "assertions": [
+    {
+      "id": "retry_limit_respected",
+      "type": "retry_count_within_declared_limit",
+      "severity": "fatal",
+      "description": "Resolver must not retry more times than declared in its failure specification"
+    }
+  ]
+}

package/R-010-output-contract/test.json

@@ -0,0 +1,28 @@
+{
+  "test_id": "R-010-output-contract",
+  "protocol_version": "1.1",
+  "category": "resolver-runtime",
+  "description": "Ensures resolver output conforms to its declared output contract.",
+  "spec_ref": ["§4.3 Resolver Output Contracts"],
+  "fixtures": {
+    "inputs": [
+      {
+        "invoke": {}
+      }
+    ]
+  },
+  "assertions": [
+    {
+      "id": "output_is_object",
+      "type": "output_is_object",
+      "severity": "fatal",
+      "description": "Resolver must return an object"
+    },
+    {
+      "id": "output_fields_match_contract",
+      "type": "output_fields_match_contract",
+      "severity": "fatal",
+      "description": "Returned object must contain all fields declared in outputs[]"
+    }
+  ]
+}

package/R-011-determinism/test.json

@@ -0,0 +1,23 @@
+{
+  "test_id": "R-011-determinism",
+  "protocol_version": "1.1",
+  "category": "resolver-runtime",
+  "description": "Ensures resolver produces deterministic output for identical inputs.",
+  "spec_ref": ["§5.1 Deterministic Execution"],
+  "fixtures": {
+    "inputs": [
+      {
+        "invoke": {}
+      }
+    ]
+  },
+  "assertions": [
+    {
+      "id": "same_input_same_output",
+      "type": "deterministic_output",
+      "severity": "warning",
+      "description": "Identical invocations should produce identical outputs"
+    }
+  ]
+}
+

package/R-012-side-effects/test.json

@@ -0,0 +1,23 @@
+{
+  "test_id": "R-012-side-effects",
+  "protocol_version": "1.1",
+  "category": "resolver-runtime",
+  "description": "Ensures resolver does not mutate global state or environment unexpectedly.",
+  "spec_ref": ["§5.3 Resolver Isolation"],
+  "fixtures": {
+    "inputs": [
+      {
+        "invoke": {}
+      }
+    ]
+  },
+  "assertions": [
+    {
+      "id": "no_global_mutation",
+      "type": "no_global_state_mutation",
+      "severity": "warning",
+      "description": "Resolver should not mutate global objects, process.env, or module-level state"
+    }
+  ]
+}
+

package/badges/certified.svg

@@ -0,0 +1,18 @@
+<svg xmlns='http://www.w3.org/2000/svg' width='120' height='20'>
+  <linearGradient id='b' x2='0' y2='100%'>
+    <stop offset='0' stop-color='#bbb' stop-opacity='.1'/>
+    <stop offset='1' stop-opacity='.1'/>
+  </linearGradient>
+  <mask id='a'>
+    <rect width='120' height='20' rx='3' fill='#fff'/>
+  </mask>
+  <g mask='url(#a)'>
+    <rect width='70' height='20' fill='#555'/>
+    <rect x='70' width='50' height='20' fill='red'/>
+    <rect width='120' height='20' fill='url(#b)'/>
+  </g>
+  <g fill='#fff' text-anchor='middle' font-family='Verdana' font-size='11'>
+    <text x='35' y='14'>Certified</text>
+    <text x='95' y='14'>fail</text>
+  </g>
+</svg>

package/lib/runner.js

@@ -1,96 +1,6 @@
 const path = require("path");
 const fs = require("fs");
 
-// ----------------------
-// Helper: Deep get by path (e.g., "steps[0].saveAs")
-// ----------------------
-function getNestedValue(obj, path) {
-  if (!path) return obj;
-  return path
-    .split(/\.(?![^\[]*\])|[\[\]]/)
-    .filter(Boolean)
-    .reduce((cur, prop) => cur?.[prop], obj);
-}
-
-// ----------------------
-// Validator functions for WORKFLOW AST
-// ----------------------
-function checkAllowlist(ast, expected) {
-  const allowed = ast.allowedResolvers || [];
-  return (
-    Array.isArray(allowed) &&
-    allowed.length === expected.length &&
-    expected.every(r => allowed.includes(r))
-  );
-}
-
-function checkResolverNameNormalization(ast) {
-  const allowed = ast.allowedResolvers || [];
-  const pattern = /^[a-zA-Z][a-zA-Z0-9]*$/;
-  return Array.isArray(allowed) && allowed.every(name => pattern.test(name));
-}
-
-function checkWorkflowName(ast, expected) {
-  return ast.name === expected;
-}
-
-function checkReturnValues(ast, expected) {
-  const returns = ast.returnValues || [];
-  return (
-    Array.isArray(returns) &&
-    returns.length === expected.length &&
-    expected.every(v => returns.includes(v))
-  );
-}
-
-function checkNoWarnings(status, expectedCount = 0) {
-  const warnings = status?.__warnings || [];
-  return warnings.length === expectedCount;
-}
-
-function checkStepType(ast, assertion) {
-  const steps = ast.steps || [];
-  const step = steps[assertion.stepIndex];
-  return step && step.type === assertion.expected;
-}
-
-function checkStepSaveAs(ast, assertion) {
-  const steps = ast.steps || [];
-  const step = steps[assertion.stepIndex];
-  return step && step.saveAs === assertion.expected;
-}
-
-function checkStepFailurePolicies(ast, assertion) {
-  const steps = ast.steps || [];
-  const step = steps[assertion.stepIndex];
-  if (!step || !step.failurePolicies) return false;
-
-  const expected = assertion.expected;
-  return Object.keys(expected).every(code => {
-    const policy = step.failurePolicies[code];
-    return (
-      policy &&
-      policy.action === expected[code].action &&
-      policy.count === expected[code].count
-    );
-  });
-}
-
-function checkContainsWarning(status, assertion) {
-  const warnings = status?.__warnings || [];
-  const needle = assertion.expected_substring.toLowerCase();
-  return warnings.some(w =>
-    (typeof w === "string" ? w : w.message || "")
-      .toLowerCase()
-      .includes(needle)
-  );
-}
-
-function checkStatusGreaterThan(status, assertion) {
-  const value = getNestedValue(status, assertion.path);
-  return typeof value === "number" && value > assertion.expected;
-}
-
 // ----------------------
 // Validator functions for RESOLVER METADATA (R-005)
 // ----------------------
@@ -147,59 +57,71 @@ function checkResolverFailuresValid(resolverMeta) {
 }
 
 // ----------------------
-// Assertion handler registry
+// Validator functions for RESOLVER RUNTIME (R-006 → R-012)
 // ----------------------
-const assertionHandlers = {
-  // Workflow AST assertions
-  allowed_resolvers_listed: (ast, assertion) =>
-    checkAllowlist(ast, assertion.expected),
-
-  resolver_names_normalized: ast =>
-    checkResolverNameNormalization(ast),
 
-  workflow_name_present: (ast, assertion) =>
-    checkWorkflowName(ast, assertion.expected),
-
-  workflow_return_values: (ast, assertion) =>
-    checkReturnValues(ast, assertion.expected),
+function checkResolverIsCallable(resolver) {
+  return typeof resolver === 'function';
+}
 
-  workflow_return_values_empty: (ast, assertion) =>
-    checkReturnValues(ast, assertion.expected),
+function checkFailureCodeDeclared(observedError, resolverMeta) {
+  if (!observedError?.code) return true; // no error = pass
+  const declaredCodes = (resolverMeta.failures || []).map(f => f.code);
+  return declaredCodes.includes(observedError.code);
+}
 
-  no_parse_warnings: (ast, assertion, status) =>
-    checkNoWarnings(status, assertion.expected),
+function checkRejectsMissingRequiredInput(invocationResult) {
+  return invocationResult.threw; // must throw when required input missing
+}
 
-  step_type: (ast, assertion) =>
-    checkStepType(ast, assertion),
+function checkRetryCountWithinLimit(observedRetries, resolverMeta, errorCode) {
+  const failure = (resolverMeta.failures || []).find(f => f.code === errorCode);
+  if (!failure) return true;
+  return observedRetries <= failure.retries;
+}
 
-  step_saveas: (ast, assertion) =>
-    checkStepSaveAs(ast, assertion),
+function checkOutputIsObject(output) {
+  return output !== null && typeof output === 'object' && !Array.isArray(output);
+}
 
-  step_failure_policies: (ast, assertion) =>
-    checkStepFailurePolicies(ast, assertion),
+function checkOutputFieldsMatchContract(output, resolverMeta) {
+  const declaredNames = (resolverMeta.outputs || []).map(o => o.name);
+  return declaredNames.every(name => name in output);
+}
 
-  // Negative test assertions (R-004)
-  contains_warning: (ast, assertion, status) =>
-    checkContainsWarning(status, assertion),
+function checkDeterministicOutput(results) {
+  if (results.length < 2) return true;
+  const first = JSON.stringify(results[0]);
+  return results.slice(1).every(r => JSON.stringify(r) === first);
+}
 
-  status_greater_than: (ast, assertion, status) =>
-    checkStatusGreaterThan(status, assertion),
+function checkNoGlobalMutation() {
+  // Placeholder: real impl would compare global state snapshots
+  return true;
+}
 
-  // Resolver metadata assertions (R-005)
+// ----------------------
+// Assertion handler registry.
+// ----------------------
+const assertionHandlers = {
+  // R-005: Metadata
   resolver_has_field: (resolverMeta, assertion) =>
     checkResolverHasField(resolverMeta, assertion),
-
-  resolver_inputs_valid: resolverMeta =>
-    checkResolverInputsValid(resolverMeta),
-
-  resolver_outputs_valid: resolverMeta =>
-    checkResolverOutputsValid(resolverMeta),
-
-  field_names_normalized: (resolverMeta, assertion) =>
-    checkFieldNamesNormalized(resolverMeta, assertion),
-
-  resolver_failures_valid: resolverMeta =>
-    checkResolverFailuresValid(resolverMeta),
+  resolver_inputs_valid: checkResolverInputsValid,
+  resolver_outputs_valid: checkResolverOutputsValid,
+  field_names_normalized: checkFieldNamesNormalized,
+  resolver_failures_valid: checkResolverFailuresValid,
+
+  // R-006–R-012: Runtime
+  resolver_is_callable: (ctx) => checkResolverIsCallable(ctx.resolver),
+  resolver_failure_declared: (ctx) => checkFailureCodeDeclared(ctx.error, ctx.resolverMeta),
+  rejects_missing_required_input: (ctx) => checkRejectsMissingRequiredInput(ctx),
+  retry_count_within_declared_limit: (ctx) =>
+    checkRetryCountWithinLimit(ctx.retryCount, ctx.resolverMeta, ctx.error?.code),
+  output_is_object: (ctx) => checkOutputIsObject(ctx.output),
+  output_fields_match_contract: (ctx) => checkOutputFieldsMatchContract(ctx.output, ctx.resolverMeta),
+  deterministic_output: (ctx) => checkDeterministicOutput(ctx.outputs),
+  no_global_state_mutation: () => checkNoGlobalMutation(),
 };
 
 // ----------------------
@@ -241,20 +163,58 @@ function runAssertions(testSpec, target, status = {}) {
     message:
       failures.length === 0
         ? "All assertions passed"
-        : failures
-            .map(f => `[${f.severity}] ${f.id}: ${f.message}`)
-            .join("; "),
+        : failures.map(f => `[${f.severity}] ${f.id}: ${f.message}`).join("; "),
     failures,
   };
 }
 
+// ----------------------
+// Runtime resolver invoker with observation
+// ----------------------
+async function invokeResolverWithObservation(resolver, resolverMeta, testSpec) {
+  const ctx = {
+    resolver,
+    resolverMeta,
+    output: null,
+    outputs: [],
+    error: null,
+    threw: false,
+    retryCount: 0,
+  };
+
+  // Use empty input — resolver must handle its own validation
+  const input = {};
+
+  // Run multiple times for determinism test
+  const runs = testSpec.test_id === 'R-011-determinism' ? 3 : 1;
+
+  for (let i = 0; i < runs; i++) {
+    try {
+      const result = await Promise.resolve(resolver(input));
+      ctx.output = result;
+      ctx.outputs.push(result);
+    } catch (err) {
+      ctx.threw = true;
+      ctx.error = err;
+      // Simple retry count inference (real impl would use retry loop)
+      if (err.code) {
+        const decl = resolverMeta.failures?.find(f => f.code === err.code);
+        if (decl) ctx.retryCount = decl.retries;
+      }
+      break; // stop on first error for non-determinism tests
+    }
+  }
+
+  return ctx;
+}
+
 // ----------------------
 // Test suite executor
 // ----------------------
 async function runAllTests({ suites, resolver }) {
   let failed = 0;
-  // Resolve test suites from the package root (where R-001-..., R-005-... live)
   const PACKAGE_ROOT = path.join(__dirname, '..');
+  const resolverMeta = resolver.resolverDeclaration || resolver;
 
   for (const suite of suites) {
     const suiteDir = path.join(PACKAGE_ROOT, suite);
@@ -267,65 +227,52 @@ async function runAllTests({ suites, resolver }) {
     }
 
     const testSpec = JSON.parse(fs.readFileSync(testSpecPath, "utf8"));
-    let target;
-    let status = {};
-
     const fixture = testSpec.fixtures.inputs[0];
 
-    if (fixture.workflow) {
-      // Workflow parsing test (R-001 → R-004)
-      const workflowPath = path.join(suiteDir, fixture.workflow);
-      if (!fs.existsSync(workflowPath)) {
-        console.error(`❌ Workflow file missing: ${workflowPath}`);
+    if (fixture.resolver_contract) {
+      // R-005: Validate metadata structure
+      const contractPath = path.join(suiteDir, fixture.resolver_contract);
+      if (!fs.existsSync(contractPath)) {
+        console.error(`❌ Resolver contract missing: ${contractPath}`);
         failed++;
         continue;
       }
 
-      const workflowSource = fs.readFileSync(workflowPath, "utf8");
+      let target;
       try {
-        const parseResult = resolver.parse
-          ? resolver.parse(workflowSource)
-          : { ast: resolver };
-
-        target = parseResult.ast;
-        status = { __warnings: parseResult.__warnings || [] };
+        target = require(contractPath);
       } catch (err) {
-        console.error(`❌ Parse failed for ${suite}:`, err.message);
+        console.error(`❌ Failed to load resolver contract ${suite}:`, err.message);
         failed++;
         continue;
       }
-    } else if (fixture.resolver_contract) {
-      // Resolver metadata test (R-005)
-      const contractPath = path.join(suiteDir, fixture.resolver_contract);
-      if (!fs.existsSync(contractPath)) {
-        console.error(`❌ Resolver contract missing: ${contractPath}`);
+
+      const result = runAssertions(testSpec, target);
+      if (!result.ok) {
+        console.error(`❌ ${suite} failed: ${result.message}`);
         failed++;
-        continue;
+      } else {
+        console.log(`✅ ${suite} passed`);
       }
-
+    } else if (testSpec.category === "resolver-runtime") {
+      // R-006 → R-012: Observe real resolver behavior
       try {
-        target = require(contractPath);
+        const runtimeContext = await invokeResolverWithObservation(resolver, resolverMeta, testSpec);
+        const result = runAssertions(testSpec, runtimeContext);
+
+        if (!result.ok) {
+          console.error(`❌ ${suite} failed: ${result.message}`);
+          failed++;
+        } else {
+          console.log(`✅ ${suite} passed`);
+        }
       } catch (err) {
-        console.error(
-          `❌ Failed to load resolver contract ${suite}:`,
-          err.message
-        );
+        console.error(`🔥 Runtime test ${suite} crashed:`, err.message);
         failed++;
-        continue;
       }
     } else {
       console.error(`❌ Unrecognized fixture in ${suite}`);
       failed++;
-      continue;
-    }
-
-    const result = runAssertions(testSpec, target, status);
-
-    if (!result.ok) {
-      console.error(`❌ ${suite} failed: ${result.message}`);
-      failed++;
-    } else {
-      console.log(`✅ ${suite} passed`);
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@o-lang/resolver-tests",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Official O-Lang Resolver Test Harness — locked single entrypoint",
   "main": "run.js",
   "type": "commonjs",

package/run.js

@@ -72,10 +72,14 @@ const { generateBadge } = require("./lib/badge");
       opts.suites.length > 0
         ? opts.suites
         : [
-            "R-001-allowlist",
-            "R-002-io-contract",
-            "R-003-failure-modes",
-            "R-005-resolver-metadata-contract"
+        "R-005-resolver-metadata-contract",
+        "R-006-runtime-shape",
+        "R-007-failure-contract",
+        "R-008-input-validation",
+        "R-009-retry-semantics",
+        "R-010-output-contract",
+        "R-011-determinism",
+        "R-012-side-effects"
           ];
 
     const result = await runAllTests({

package/R-001-allowlist/README.md

@@ -1,21 +0,0 @@
-# R-001 Allowlist Resolver Test
-
-**Purpose:**  
-This test verifies that the O-Lang parser correctly captures and normalizes the list of allowed resolvers declared in a workflow.
-
-**Workflow:**  
-- Workflow Name: `TestResolverAllowlist`
-- Allowed Resolvers:
-  - `SimpleResolver`
-  - `AdvancedResolver`
-
-**Assertions:**  
-1. All allowed resolvers are captured correctly.  
-2. Resolver names are normalized (no spaces, invalid characters).  
-3. Workflow name is correctly parsed.  
-4. No parser warnings are generated for valid syntax.
-
-**Spec References:**  
-- §4.2 Allowed Resolvers  
-- §3.1 Workflow Parsing  
-- §2.3 Symbol Normalization

package/R-001-allowlist/test.json

@@ -1,55 +0,0 @@
-{
-  "test_id": "R-001-allowlist",
-  "protocol_version": "1.1",
-  "category": "resolver",
-  "description": "Tests that the parser correctly captures and normalizes allowed resolvers.",
-  "spec_ref": [
-    "§4.2 Allowed Resolvers",
-    "§3.1 Workflow Parsing",
-    "§2.3 Symbol Normalization"
-  ],
-  "fixtures": {
-    "inputs": [
-      {
-        "workflow": "workflow.ol",
-        "values": {}
-      }
-    ]
-  },
-  "assertions": [
-    {
-      "id": "allowed_resolvers_listed",
-      "type": "allowed_resolvers_listed",
-      "expected": ["SimpleResolver", "AdvancedResolver"],
-      "severity": "fatal",
-      "description": "Parser must capture all allowed resolvers"
-    },
-    {
-      "id": "resolver_names_normalized",
-      "type": "resolver_names_normalized",
-      "severity": "fatal",
-      "description": "All resolver names must conform to symbol normalization rules (start with letter, alphanumeric only)"
-    },
-    {
-      "id": "workflow_name_present",
-      "type": "workflow_name_present",
-      "expected": "TestResolverAllowlist",
-      "severity": "fatal",
-      "description": "Workflow name must be parsed correctly"
-    },
-    {
-      "id": "workflow_return_values_empty",
-      "type": "workflow_return_values_empty",
-      "expected": [],
-      "severity": "fatal",
-      "description": "Return values must be empty as per workflow"
-    },
-    {
-      "id": "no_parse_warnings",
-      "type": "no_parse_warnings",
-      "expected": 0,
-      "severity": "warning",
-      "description": "No warnings should be issued for valid syntax"
-    }
-  ]
-}

package/R-001-allowlist/workflow.ol

@@ -1,7 +0,0 @@
-Workflow "TestResolverAllowlist"
-
-Allow resolvers:
-- SimpleResolver
-- AdvancedResolver
-
-Return

package/R-002-io-contract/README.md

@@ -1,26 +0,0 @@
-# R-002 IO Contract Resolver Test
-
-**Purpose:**  
-This test validates that resolver input/output contracts are correctly recognized, including the proper handling of `Ask` and `Use` steps, and that `saveAs` values are normalized.
-
-**Workflow:**  
-- Workflow Name: `TestResolverIOContract`
-- Parameters: `userInput`
-- Allowed Resolvers:
-  - `Calculator`
-  - `WeatherService`
-- Steps:
-  1. `Ask Calculator` → `saveAs: calcResult`
-  2. `Use WeatherService` → `saveAs: weatherInfo`
-- Return Values: `calcResult, weatherInfo`
-
-**Assertions:**  
-1. Step 1 is parsed as an `ask` step with normalized `saveAs`.  
-2. Step 2 is parsed as a `use` step with normalized `saveAs`.  
-3. Return statement lists all resolver outputs.  
-4. No parser warnings are generated.
-
-**Spec References:**  
-- §4.3 Resolver Input/Output Contracts  
-- §3.2 Step Parsing  
-- §2.3 Symbol Normalization

package/R-002-io-contract/test.json

@@ -1,76 +0,0 @@
-{
-  "test_id": "R-002-io-contract",
-  "protocol_version": "1.1",
-  "category": "resolver",
-  "description": "Tests that resolver I/O contracts are correctly recognized and saveAs fields are applied.",
-  "spec_ref": [
-    "§4.3 Resolver Input/Output Contracts",
-    "§3.2 Step Parsing",
-    "§2.3 Symbol Normalization"
-  ],
-  "fixtures": {
-    "inputs": [
-      {
-        "workflow": "workflow.ol",
-        "values": {
-          "userInput": "42"
-        }
-      }
-    ]
-  },
-  "assertions": [
-    {
-      "id": "allowed_resolvers_listed",
-      "type": "allowed_resolvers_listed",
-      "expected": ["Calculator", "WeatherService"],
-      "severity": "fatal",
-      "description": "Parser must capture all allowed resolvers"
-    },
-    {
-      "id": "ask_step_type",
-      "type": "step_type",
-      "stepIndex": 0,
-      "expected": "ask",
-      "severity": "fatal",
-      "description": "Step 1 must be parsed as 'ask'"
-    },
-    {
-      "id": "ask_step_saveas",
-      "type": "step_saveas",
-      "stepIndex": 0,
-      "expected": "calcResult",
-      "severity": "fatal",
-      "description": "Step 1 saveAs must be 'calcResult'"
-    },
-    {
-      "id": "use_step_type",
-      "type": "step_type",
-      "stepIndex": 1,
-      "expected": "use",
-      "severity": "fatal",
-      "description": "Step 2 must be parsed as 'use'"
-    },
-    {
-      "id": "use_step_saveas",
-      "type": "step_saveas",
-      "stepIndex": 1,
-      "expected": "weatherInfo",
-      "severity": "fatal",
-      "description": "Step 2 saveAs must be 'weatherInfo'"
-    },
-    {
-      "id": "workflow_return_values",
-      "type": "workflow_return_values",
-      "expected": ["calcResult", "weatherInfo"],
-      "severity": "fatal",
-      "description": "Return statement must list all saved outputs"
-    },
-    {
-      "id": "no_parse_warnings",
-      "type": "no_parse_warnings",
-      "expected": 0,
-      "severity": "warning",
-      "description": "No warnings for valid I/O contracts"
-    }
-  ]
-}

package/R-002-io-contract/workflow.ol

@@ -1,13 +0,0 @@
-Workflow "TestResolverIOContract" with userInput
-
-Allow resolvers:
-- Calculator
-- WeatherService
-
-Step 1: Ask Calculator
-Save as calcResult
-
-Step 2: Use WeatherService
-Save as weatherInfo
-
-Return calcResult, weatherInfo

package/R-003-failure-modes/README

@@ -1,27 +0,0 @@
-# R-003 Failure Modes Resolver Test
-
-**Purpose:**  
-This test validates that resolver failures, missing resolvers, and runtime errors are correctly handled and surfaced by the parser/runtime.
-
-**Workflow:**  
-- Workflow Name: `TestResolverFailureModes`
-- Parameters: `userInput`
-- Allowed Resolvers:
-  - `ReliableResolver`
-  - `UnstableResolver`
-- Steps:
-  1. `Ask ReliableResolver` → `saveAs: reliableResult`
-  2. `Ask UnstableResolver` → `saveAs: unstableResult`
-- Return Values: `reliableResult, unstableResult`
-
-**Assertions:**  
-1. Steps 1 & 2 are correctly parsed as `ask` resolver steps.  
-2. `saveAs` values are normalized.  
-3. Return statement lists all resolver outputs.  
-4. Errors from failing resolvers (e.g., `UnstableResolver`) are surfaced.  
-5. Missing resolvers (e.g., `MissingResolver`) trigger proper errors.
-
-**Spec References:**  
-- §4.4 Resolver Failure Modes  
-- §3.2 Step Parsing  
-- §5.1 Error Handling

package/R-003-failure-modes/test.json

@@ -1,78 +0,0 @@
-{
-  "test_id": "R-003-failure-modes",
-  "protocol_version": "1.1",
-  "category": "resolver",
-  "description": "Tests that resolver failure modes and retry policies are parsed and exposed.",
-  "spec_ref": [
-    "§4.4 Resolver Failure Modes",
-    "§3.3 Step Parsing",
-    "§2.3 Symbol Normalization"
-  ],
-  "fixtures": {
-    "inputs": [
-      {
-        "workflow": "workflow.ol",
-        "values": {
-          "userInput": "someInput"
-        }
-      }
-    ]
-  },
-  "assertions": [
-    {
-      "id": "allowed_resolvers_listed",
-      "type": "allowed_resolvers_listed",
-      "expected": ["ReliableResolver", "UnstableResolver"],
-      "severity": "fatal",
-      "description": "Allowed resolvers must be captured"
-    },
-    {
-      "id": "step_0_saveas",
-      "type": "step_saveas",
-      "stepIndex": 0,
-      "expected": "reliableResult",
-      "severity": "fatal",
-      "description": "Step 0 saveAs"
-    },
-    {
-      "id": "step_1_saveas",
-      "type": "step_saveas",
-      "stepIndex": 1,
-      "expected": "unstableResult",
-      "severity": "fatal",
-      "description": "Step 1 saveAs"
-    },
-    {
-      "id": "workflow_name_present",
-      "type": "workflow_name_present",
-      "expected": "TestResolverFailureModes",
-      "severity": "fatal",
-      "description": "Workflow name parsed"
-    },
-    {
-      "id": "workflow_return_values",
-      "type": "workflow_return_values",
-      "expected": ["reliableResult", "unstableResult"],
-      "severity": "fatal",
-      "description": "Return values listed"
-    },
-    {
-      "id": "unstable_resolver_failure_policies",
-      "type": "step_failure_policies",
-      "stepIndex": 1,
-      "expected": {
-        "TIMEOUT": { "action": "retry", "count": 2 },
-        "NETWORK_ERROR": { "action": "fail", "count": 0 }
-      },
-      "severity": "fatal",
-      "description": "Failure modes and retry counts must be parsed"
-    },
-    {
-      "id": "no_parse_warnings",
-      "type": "no_parse_warnings",
-      "expected": 0,
-      "severity": "warning",
-      "description": "No warnings for valid failure mode syntax"
-    }
-  ]
-}

package/R-003-failure-modes/workflow.ol

@@ -1,13 +0,0 @@
-Workflow "TestResolverFailureModes" with userInput
-
-Allow resolvers:
-- ReliableResolver
-- UnstableResolver
-
-Step 1: Ask ReliableResolver
-Save as reliableResult
-
-Step 2: Ask UnstableResolver
-Save as unstableResult
-
-Return reliableResult, unstableResult

package/R-004-invalid-syntax/README.md

@@ -1,5 +0,0 @@
-# R-005: Resolver Metadata Contract
-
-Validates that resolver packages declare valid **inputs**, **outputs**, **resolverName**, and **failure modes**.
-
-This test ensures that static resolver contracts (e.g., `resolver.js`) are well-formed and align with O-lang’s governance model—enabling tooling, linting, and safe composition.

package/R-004-invalid-syntax/test.json

@@ -1,57 +0,0 @@
-{
-  "test_id": "R-004-invalid-syntax",
-  "protocol_version": "1.1",
-  "category": "resolver",
-  "description": "Tests that parser emits warnings or errors for invalid syntax.",
-  "spec_ref": [
-    "§2.3 Symbol Normalization",
-    "§3.1 Workflow Parsing",
-    "§4.2 Allowed Resolvers"
-  ],
-  "fixtures": {
-    "inputs": [
-      {
-        "workflow": "workflow.ol",
-        "values": {}
-      }
-    ]
-  },
-  "assertions": [
-    {
-      "id": "warns_on_invalid_resolver_name",
-      "type": "contains_warning",
-      "expected_substring": "invalid resolver name",
-      "severity": "fatal",
-      "description": "Must warn about resolver name with space"
-    },
-    {
-      "id": "warns_on_invalid_saveas",
-      "type": "contains_warning",
-      "expected_substring": "invalid identifier",
-      "severity": "fatal",
-      "description": "Must warn about malformed Save as"
-    },
-    {
-      "id": "warns_on_unrecognized_step",
-      "type": "contains_warning",
-      "expected_substring": "unrecognized step",
-      "severity": "fatal",
-      "description": "Must warn about unknown step type"
-    },
-    {
-      "id": "warns_on_duplicate_saveas",
-      "type": "contains_warning",
-      "expected_substring": "duplicate saveAs",
-      "severity": "fatal",
-      "description": "Must warn about duplicate Save as names"
-    },
-    {
-      "id": "parse_status_has_warnings",
-      "type": "status_greater_than",
-      "path": "__warnings.length",
-      "expected": 0,
-      "severity": "fatal",
-      "description": "Parser must emit at least one warning"
-    }
-  ]
-}

package/R-004-invalid-syntax/workflow.ol

@@ -1,16 +0,0 @@
-// resolver.ol (treated as a JS module in test)
-module.exports = {
-  resolverName: "RiskAssessment",
-  inputs: [
-    { name: "transaction_id", type: "string", required: true },
-    { name: "user_id", type: "string", required: true }
-  ],
-  outputs: [
-    { name: "risk_score", type: "number" },
-    { name: "confidence", type: "number" }
-  ],
-  failures: [
-    { code: "DATA_UNAVAILABLE", retries: 1 },
-    { code: "MODEL_ERROR", retries: 0 }
-  ]
-};

package/certified.svg

@@ -1,6 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="160" height="28">
-  <rect rx="4" width="160" height="28" fill="#2d2d2d"/>
-  <rect rx="4" x="80" width="80" height="28" fill="#4cbb17"/>
-  <text x="40" y="18" fill="#fff" font-size="13" font-family="Arial" text-anchor="middle">O-lang</text>
-  <text x="120" y="18" fill="#fff" font-size="13" font-family="Arial" text-anchor="middle">CERTIFIED</text>
-</svg>