@kylecheng3146/agent-ops 0.5.2 → 0.6.0

package/schemas/evidence.schema.json

@@ -24,7 +24,11 @@
   ],
   "properties": {
     "schemaVersion": {
-      "enum": [2, 3]
+      "enum": [
+        2,
+        3,
+        4
+      ]
     },
     "taskId": {
       "$ref": "#/$defs/id"
@@ -47,7 +51,10 @@
       "$ref": "#/$defs/relativePath"
     },
     "scope": {
-      "enum": ["project", "user"]
+      "enum": [
+        "project",
+        "user"
+      ]
     },
     "startedAt": {
       "$ref": "#/$defs/timestamp"
@@ -56,17 +63,27 @@
       "$ref": "#/$defs/timestamp"
     },
     "exitCode": {
-      "type": ["integer", "null"],
+      "type": [
+        "integer",
+        "null"
+      ],
       "minimum": 0,
       "maximum": 4294967295
     },
     "testCount": {
-      "type": ["integer", "null"],
+      "type": [
+        "integer",
+        "null"
+      ],
       "minimum": 0,
       "maximum": 9007199254740991
     },
     "status": {
-      "enum": ["PASS", "FAIL", "UNKNOWN"]
+      "enum": [
+        "PASS",
+        "FAIL",
+        "UNKNOWN"
+      ]
     },
     "failureClass": {
       "type": "string",
@@ -85,6 +102,92 @@
     },
     "configHash": {
       "$ref": "#/$defs/hash"
+    },
+    "taskContractHash": {
+      "type": "string",
+      "pattern": "^[a-f0-9]{64}$"
+    },
+    "acceptance": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "criterionContractHash",
+        "phase",
+        "commit",
+        "pairedCommit",
+        "materialDigest",
+        "executionDigest",
+        "checks",
+        "bindingHash",
+        "executionArtifact"
+      ],
+      "properties": {
+        "criterionContractHash": {
+          "type": "string",
+          "pattern": "^[a-f0-9]{64}$"
+        },
+        "phase": {
+          "enum": [
+            "baseline",
+            "candidate"
+          ]
+        },
+        "commit": {
+          "type": "string",
+          "pattern": "^(?:[a-f0-9]{40}|[a-f0-9]{64})$"
+        },
+        "pairedCommit": {
+          "type": "string",
+          "pattern": "^(?:[a-f0-9]{40}|[a-f0-9]{64})$"
+        },
+        "materialDigest": {
+          "type": "string",
+          "pattern": "^[a-f0-9]{64}$"
+        },
+        "executionDigest": {
+          "type": "string",
+          "pattern": "^[a-f0-9]{64}$"
+        },
+        "checks": {
+          "type": "array",
+          "minItems": 1,
+          "maxItems": 512,
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": [
+              "checkId",
+              "status",
+              "failureClass"
+            ],
+            "properties": {
+              "checkId": {
+                "type": "string",
+                "minLength": 1
+              },
+              "status": {
+                "enum": [
+                  "PASS",
+                  "FAIL",
+                  "UNKNOWN"
+                ]
+              },
+              "failureClass": {
+                "type": "string",
+                "minLength": 1
+              }
+            }
+          }
+        },
+        "bindingHash": {
+          "type": "string",
+          "pattern": "^[a-f0-9]{64}$"
+        },
+        "executionArtifact": {
+          "type": "string",
+          "pattern": "^\\.agent-ops/tasks/acceptance/[a-f0-9]{64}\\.json$"
+        }
+      }
     }
   },
   "$defs": {
@@ -126,5 +229,25 @@
       ]
     }
   },
-  "$comment": "Timestamp ordering is a semantic constraint enforced by runtime validation."
+  "$comment": "Timestamp ordering is a semantic constraint enforced by runtime validation.",
+  "allOf": [
+    {
+      "if": {
+        "properties": {
+          "schemaVersion": {
+            "enum": [
+              2,
+              3
+            ]
+          }
+        }
+      },
+      "then": {
+        "properties": {
+          "taskContractHash": false,
+          "acceptance": false
+        }
+      }
+    }
+  ]
 }

package/schemas/task.schema.json

@@ -4,10 +4,18 @@
   "title": "Agent Ops task",
   "type": "object",
   "additionalProperties": false,
-  "required": ["schemaVersion", "id", "title", "criteria"],
+  "required": [
+    "schemaVersion",
+    "id",
+    "title",
+    "criteria"
+  ],
   "properties": {
     "schemaVersion": {
-      "const": 1
+      "enum": [
+        1,
+        2
+      ]
     },
     "id": {
       "$ref": "#/$defs/id"
@@ -15,6 +23,9 @@
     "title": {
       "$ref": "#/$defs/nonEmptyString"
     },
+    "intent": {
+      "$ref": "#/$defs/nonEmptyString"
+    },
     "parentTaskId": {
       "$ref": "#/$defs/id"
     },
@@ -25,7 +36,11 @@
       "items": {
         "type": "object",
         "additionalProperties": false,
-        "required": ["id", "description", "verifierIds"],
+        "required": [
+          "id",
+          "description",
+          "verifierIds"
+        ],
         "properties": {
           "id": {
             "$ref": "#/$defs/id"
@@ -35,14 +50,232 @@
           },
           "verifierIds": {
             "type": "array",
-            "minItems": 1,
+            "minItems": 0,
             "uniqueItems": true,
             "items": {
               "$ref": "#/$defs/id"
             }
+          },
+          "acceptance": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": [
+              "mode",
+              "baselineCommit",
+              "bindings"
+            ],
+            "properties": {
+              "mode": {
+                "enum": [
+                  "behavioral",
+                  "invariant",
+                  "review-only"
+                ]
+              },
+              "baselineCommit": {
+                "type": "string",
+                "pattern": "^(?:[a-f0-9]{40}|[a-f0-9]{64})$"
+              },
+              "reviewOnlyReason": {
+                "type": "string",
+                "minLength": 1,
+                "maxLength": 4096,
+                "pattern": "\\S"
+              },
+              "bindings": {
+                "type": "array",
+                "maxItems": 64,
+                "items": {
+                  "type": "object",
+                  "additionalProperties": false,
+                  "required": [
+                    "runnerId",
+                    "checkIds",
+                    "materials"
+                  ],
+                  "properties": {
+                    "runnerId": {
+                      "$ref": "#/$defs/id"
+                    },
+                    "checkIds": {
+                      "type": "array",
+                      "maxItems": 512,
+                      "uniqueItems": true,
+                      "items": {
+                        "type": "string",
+                        "minLength": 1
+                      },
+                      "minItems": 1
+                    },
+                    "redCheckIds": {
+                      "type": "array",
+                      "maxItems": 512,
+                      "uniqueItems": true,
+                      "items": {
+                        "type": "string",
+                        "minLength": 1
+                      }
+                    },
+                    "materials": {
+                      "type": "array",
+                      "minItems": 1,
+                      "maxItems": 512,
+                      "items": {
+                        "type": "object",
+                        "additionalProperties": false,
+                        "required": [
+                          "path",
+                          "role"
+                        ],
+                        "properties": {
+                          "path": {
+                            "type": "string",
+                            "minLength": 1,
+                            "maxLength": 4096,
+                            "pattern": "^[^/\\\\\\u0000]+(?:/[^/\\\\\\u0000]+)*$",
+                            "not": {
+                              "anyOf": [
+                                {
+                                  "pattern": "(?:^|/)(?:\\.{1,2}|\\.git|\\.agent-ops|node_modules)(?:/|$)"
+                                },
+                                {
+                                  "pattern": "^(?:dist|build|\\.tmp)/"
+                                },
+                                {
+                                  "enum": [
+                                    "package.json",
+                                    "package-lock.json",
+                                    "pnpm-lock.yaml",
+                                    "yarn.lock",
+                                    "Cargo.toml",
+                                    "Cargo.lock",
+                                    "pyproject.toml"
+                                  ]
+                                }
+                              ]
+                            }
+                          },
+                          "role": {
+                            "enum": [
+                              "test",
+                              "fixture",
+                              "helper"
+                            ]
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            },
+            "allOf": [
+              {
+                "if": {
+                  "properties": {
+                    "mode": {
+                      "const": "review-only"
+                    }
+                  },
+                  "type": "object"
+                },
+                "then": {
+                  "required": ["reviewOnlyReason"],
+                  "properties": {
+                    "reviewOnlyReason": {"type": "string"},
+                    "bindings": {
+                      "maxItems": 0,
+                      "type": "array"
+                    }
+                  },
+                  "type": "object"
+                },
+                "else": {
+                  "properties": {
+                    "reviewOnlyReason": false,
+                    "bindings": {
+                      "minItems": 1,
+                      "type": "array"
+                    }
+                  },
+                  "type": "object"
+                }
+              }
+            ]
+          },
+          "finding": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": [
+              "pinId",
+              "reportDigest",
+              "findingIndex",
+              "candidateCommit",
+              "criterionIds"
+            ],
+            "properties": {
+              "pinId": {
+                "type": "string",
+                "pattern": "^[a-f0-9]{64}$"
+              },
+              "reportDigest": {
+                "type": "string",
+                "pattern": "^[a-f0-9]{64}$"
+              },
+              "findingIndex": {
+                "type": "integer",
+                "minimum": 0
+              },
+              "candidateCommit": {
+                "type": "string",
+                "pattern": "^(?:[a-f0-9]{40}|[a-f0-9]{64})$"
+              },
+              "criterionIds": {
+                "type": "array",
+                "maxItems": 512,
+                "uniqueItems": true,
+                "items": {
+                  "type": "string",
+                  "minLength": 1
+                }
+              }
+            }
           }
-        }
+        },
+        "allOf": [
+          {
+            "if": {
+              "not": {
+                "required": [
+                  "acceptance"
+                ],
+                "properties": {
+                  "acceptance": {}
+                },
+                "type": "object"
+              }
+            },
+            "then": {
+              "properties": {
+                "verifierIds": {
+                  "minItems": 1,
+                  "type": "array"
+                }
+              },
+              "type": "object"
+            }
+          }
+        ]
       }
+    },
+    "goal": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 65536
+    },
+    "contractRevision": {
+      "type": "integer",
+      "minimum": 0
     }
   },
   "$defs": {
@@ -58,5 +291,34 @@
       }
     }
   },
-  "$comment": "Criterion ID uniqueness is a semantic constraint enforced by runtime validation."
+  "$comment": "Criterion ID uniqueness is a semantic constraint enforced by runtime validation.",
+  "allOf": [
+    {
+      "if": {
+        "properties": {
+          "schemaVersion": {
+            "const": 1
+          }
+        },
+        "type": "object"
+      },
+      "then": {
+        "properties": {
+          "goal": false,
+          "contractRevision": false,
+          "criteria": {
+            "items": {
+              "properties": {
+                "acceptance": false,
+                "finding": false
+              },
+              "type": "object"
+            },
+            "type": "array"
+          }
+        },
+        "type": "object"
+      }
+    }
+  ]
 }

package/templates/acceptance/agent_ops_acceptance.rs

@@ -0,0 +1,36 @@
+//! Stable stdlib acceptance harness. Compile after the product build.
+//! Tests return explicit assertion results; a panic is infrastructure UNKNOWN.
+use std::io::{self, Write};
+use std::panic::{catch_unwind, AssertUnwindSafe};
+
+fn quoted(value: &str) -> String {
+    let mut out = String::from("\"");
+    for ch in value.chars() {
+        match ch {
+            '\\' => out.push_str("\\\\"),
+            '"' => out.push_str("\\\""),
+            c if (c as u32) < 32 => out.push_str(&format!("\\u{:04x}", c as u32)),
+            c => out.push(c),
+        }
+    }
+    out.push('"'); out
+}
+
+pub struct Harness { failed: bool }
+impl Harness {
+    pub fn new() -> Self { Self { failed: false } }
+    pub fn check<F: FnOnce() -> Result<(), String>>(&mut self, id: &str, check: F) {
+        let (status, failure) = match catch_unwind(AssertUnwindSafe(check)) {
+            Ok(Ok(())) => ("PASS", "none"),
+            Ok(Err(_)) => { self.failed = true; ("FAIL", "assertion-failed") },
+            Err(_) => { self.failed = true; ("UNKNOWN", "infrastructure-error") },
+        };
+        println!("{{\"type\":\"check\",\"checkId\":{},\"status\":\"{}\",\"failureClass\":\"{}\",\"attempts\":1}}", quoted(id), status, failure);
+        io::stdout().flush().expect("acceptance output failed");
+    }
+    pub fn finish(self) -> ! {
+        println!("{{\"type\":\"completed\",\"completed\":true}}");
+        io::stdout().flush().expect("acceptance output failed");
+        std::process::exit(if self.failed { 1 } else { 0 });
+    }
+}

package/templates/acceptance/agent_ops_pytest.py

@@ -0,0 +1,46 @@
+"""Load with pytest -p agent_ops_pytest -p no:terminal (PYTHONPATH points here).
+Only AssertionError in a test call is behavioral red; fixture errors are not.
+The product checkout supplies pytest and all dependencies.
+"""
+import json
+import os
+import sys
+import pytest
+
+
+def emit(event):
+    event["executionId"] = os.environ.get("AGENT_OPS_ACCEPTANCE_EXECUTION_ID")
+    event["phase"] = os.environ.get("AGENT_OPS_ACCEPTANCE_PHASE")
+    sys.__stdout__.write(json.dumps(event, ensure_ascii=True) + "\n")
+    sys.__stdout__.flush()
+
+
+@pytest.hookimpl(hookwrapper=True)
+def pytest_runtest_makereport(item, call):
+    outcome = yield
+    report = outcome.get_result()
+    emit({"type": "test-report", "nodeid": report.nodeid,
+          "when": report.when, "outcome": report.outcome,
+          "assertion": call.excinfo is not None and call.excinfo.errisinstance(AssertionError),
+          "wasxfail": getattr(report, "wasxfail", False),
+          "attempts": int(getattr(report, "rerun", 0)) + 1})
+
+
+def pytest_collectreport(report):
+    if report.failed:
+        emit({"type": "collection-error", "nodeid": report.nodeid})
+
+
+def pytest_internalerror(excrepr, excinfo):
+    emit({"type": "internal-error"})
+
+
+def pytest_sessionfinish(session, exitstatus):
+    if int(exitstatus) not in (0, 1):
+        emit({"type": "session-error", "exitstatus": int(exitstatus)})
+    emit({"type": "session-finished", "completed": True,
+          "exitstatus": int(exitstatus), "frameworkVersion": pytest.__version__})
+
+
+if __name__ == "__main__":
+    raise SystemExit(pytest.main([*sys.argv[1:], "-p", "no:terminal", "--capture=sys"], plugins=[sys.modules[__name__]]))