@eir-labs/coltrane 0.24.30 → 0.24.32

package/domain_types/change-set.json

@@ -1,32 +1,12 @@
 {
   "slug": "change-set",
-  "version": 1,
+  "version": 3,
   "extends": "Artifact",
   "domain": "software-change",
   "status": "active",
-  "description": "The change itself, carried as content rather than applied — the seat that produces it holds a read-only grant, so the artefact is reviewable before anything mutates. departures is separate from rationale on purpose: a change that diverged from its plan and amended the record is honest, and a change that diverged silently is not distinguishable from one that did not.",
   "schema": {
     "type": "object",
     "properties": {
-      "diffs": {
-        "type": "array",
-        "description": "Per-path patch content, in unified-diff form.",
-        "items": {
-          "type": "object",
-          "properties": {
-            "path": {
-              "type": "string"
-            },
-            "patch": {
-              "type": "string"
-            }
-          },
-          "required": [
-            "path",
-            "patch"
-          ]
-        }
-      },
       "tests_added": {
         "type": "array",
         "items": {
@@ -63,13 +43,44 @@
             "why"
           ]
         }
+      },
+      "changes": {
+        "type": "array",
+        "description": "The changed files, BY ADDRESS (contract-records-by-address-v1). A seat supplies {path, base}: the file and the commit its change is measured from. The ENGINE stamps, at seal, from RunDeps.tree_root: blob_sha (git hash-object of the file, or the literal \"deleted\"), patch_sha256 (sha256 of `git diff <base> -- <path>`) and bytes (that diff's length). A consumer reads the change with `git diff <base> -- <path>` and checks it against patch_sha256. No patch body is ever model output.",
+        "items": {
+          "type": "object",
+          "properties": {
+            "path": {
+              "type": "string"
+            },
+            "base": {
+              "type": "string"
+            },
+            "blob_sha": {
+              "type": "string",
+              "description": "engine-stamped at seal"
+            },
+            "patch_sha256": {
+              "type": "string",
+              "description": "engine-stamped at seal"
+            },
+            "bytes": {
+              "type": "number",
+              "description": "engine-stamped at seal"
+            }
+          },
+          "required": [
+            "path",
+            "base"
+          ]
+        }
       }
     }
   },
   "required_fields": [
     "validation_criteria",
     "input_refs",
-    "diffs",
+    "changes",
     "rationale"
   ]
 }

package/domain_types/red-spec.json

@@ -1,6 +1,6 @@
 {
   "slug": "red-spec",
-  "version": 2,
+  "version": 4,
   "extends": "Artifact",
   "domain": "spec-drafting",
   "status": "active",
@@ -11,27 +11,6 @@
         "type": "string",
         "description": "The written spec (path added by the diffs)."
       },
-      "diffs": {
-        "type": "array",
-        "description": "Per-path unified diffs: the RED test files (real assertions, failing because unimplemented) and the spec doc.",
-        "items": {
-          "type": "object",
-          "properties": {
-            "path": {
-              "type": "string"
-            },
-            "patch": {
-              "type": "string",
-              "description": "The unified diff itself, not a description of it. The spec-drafting review chair reads test bodies OUT OF THIS FIELD ('read each red test in the diffs'), so this is the evidence the gate adjudicates, not documentation of the change. Observed on gig 34ff466b: every patch sealed as a one-line summary ('full unified diff captured from git diff --cached ... content present verbatim in the working tree at this path') — true, and useless as evidence. The reviewer refused, correctly, marking NON-TAUTOLOGY and REDNESS 'NOT RUN'. The gate was not failed, it was STARVED, and the seal accepted that silently because the type asked only for a string.",
-              "pattern": "(^|\\n)[+-]"
-            }
-          },
-          "required": [
-            "path",
-            "patch"
-          ]
-        }
-      },
       "coverage_map": {
         "type": "array",
         "description": "EVERY subsystem-contract invariant mapped to the red test that verifies it: each {invariant_id, test_name, test_file}.",
@@ -65,13 +44,43 @@
         "items": {
           "type": "string"
         }
+      },
+      "laws": {
+        "type": "array",
+        "description": "The RED laws, BY ADDRESS (contract-records-by-address-v1). A seat supplies {path, commit}: where the committed law file is. The ENGINE stamps, at seal, from RunDeps.tree_root: blob_sha (git rev-parse <commit>:<path>) and tests (the it/test titles in that blob, in file order). A reviewing seat reads the exact law with `git show <commit>:<path>` and checks it against blob_sha. No patch body is ever model output: gig c1771b13's attester hit the 32,000 output-token cap three times re-typing ~150KB of patches into the retired `diffs` field.",
+        "items": {
+          "type": "object",
+          "properties": {
+            "path": {
+              "type": "string"
+            },
+            "commit": {
+              "type": "string"
+            },
+            "blob_sha": {
+              "type": "string",
+              "description": "engine-stamped at seal; a seat-supplied value that disagrees with git is refused (law_bytes_mismatch)"
+            },
+            "tests": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "description": "engine-stamped at seal: the it/test titles in the blob, in file order"
+            }
+          },
+          "required": [
+            "path",
+            "commit"
+          ]
+        }
       }
     }
   },
   "required_fields": [
     "validation_criteria",
     "input_refs",
-    "diffs",
+    "laws",
     "coverage_map",
     "testing_method"
   ]

package/domain_types/seat-primer.json

@@ -0,0 +1,65 @@
+{
+  "slug": "seat-primer",
+  "version": 2,
+  "extends": "Signal",
+  "domain": "engine",
+  "status": "active",
+  "schema": {
+    "type": "object",
+    "properties": {
+      "agent_slug": {
+        "type": "string",
+        "description": "the agent whose seat read the area; a primer is forked only by chairs of this agent"
+      },
+      "area": {
+        "type": "string",
+        "description": "lowercase-hyphen area slug the primer covers"
+      },
+      "session_id": {
+        "type": "string",
+        "description": "the priming chair's (gig_id, role) session uuid; a fork resumes it with --fork-session"
+      },
+      "commit": {
+        "type": "string",
+        "description": "HEAD at seal"
+      },
+      "files": {
+        "type": "array",
+        "description": "every file the seat read (and, for a rolling primer, the forked primer's files), each with its git blob at seal; a changed blob is named to the fork as stale",
+        "items": {
+          "type": "object",
+          "properties": {
+            "path": {
+              "type": "string"
+            },
+            "blob_sha": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "path",
+            "blob_sha"
+          ]
+        }
+      },
+      "context_tokens": {
+        "type": "number",
+        "description": "input + cache_read + cache_creation of the seat's last usage before sealing; compared with fork_from.max_context_tokens"
+      },
+      "source": {
+        "type": "string"
+      },
+      "frontier": {
+        "type": "string",
+        "description": "uuid of the last user line before the seat's first write-tool call (Write, Edit, MultiEdit, NotebookEdit); a fork resumes the primer's session cut there with --resume-session-at, so it loads what the seat read and never what it then did. Absent when the seat wrote nothing or no user line preceded its first write: the fork then resumes the whole session."
+      }
+    }
+  },
+  "required_fields": [
+    "agent_slug",
+    "area",
+    "session_id",
+    "commit",
+    "files"
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eir-labs/coltrane",
-  "version": "0.24.30",
+  "version": "0.24.32",
   "description": "A methodology engine \u2014 a typed substrate for defining agents, composing multi-phase standards, dispatching gigs, and sealing every output to a content-addressed ledger. Ships as an MCP server.",
   "type": "module",
   "license": "Apache-2.0",

package/standards/build-from-red-spec-v0.json

@@ -0,0 +1,93 @@
+{
+  "slug": "build-from-red-spec-v0",
+  "domain": "software-change",
+  "agent_slugs": [
+    "red-spec-attester",
+    "red-spec-builder",
+    "change-verifier"
+  ],
+  "phases": [
+    {
+      "name": "attest-laws",
+      "chairs": [
+        {
+          "role": "attest-laws",
+          "agent_slug": "red-spec-attester",
+          "depends_on": [],
+          "input_contract": [
+            "change-request"
+          ],
+          "output_contract": [
+            "red-spec"
+          ],
+          "required_skills": [],
+          "turn_reserve": 8
+        }
+      ]
+    },
+    {
+      "name": "build",
+      "chairs": [
+        {
+          "role": "build-change",
+          "agent_slug": "red-spec-builder",
+          "depends_on": [
+            "attest-laws"
+          ],
+          "input_contract": [
+            "change-plan",
+            "red-spec"
+          ],
+          "output_contract": [
+            "change-set"
+          ],
+          "required_skills": [],
+          "turn_reserve": 16,
+          "prime": {
+            "area": "coltrane-engine"
+          },
+          "fork_from": {
+            "primer": "coltrane-engine",
+            "max_context_tokens": 150000
+          }
+        }
+      ]
+    },
+    {
+      "name": "verify",
+      "chairs": [
+        {
+          "role": "verify-change",
+          "agent_slug": "change-verifier",
+          "depends_on": [
+            "attest-laws",
+            "build-change"
+          ],
+          "input_contract": [
+            "change-plan",
+            "change-set",
+            "red-spec"
+          ],
+          "output_contract": [
+            "change-verdict"
+          ],
+          "required_skills": [],
+          "turn_reserve": 10
+        }
+      ]
+    }
+  ],
+  "status": "draft",
+  "input_types": [
+    "change-request",
+    "change-plan"
+  ],
+  "output_types": [
+    "red-spec",
+    "change-set",
+    "change-verdict"
+  ],
+  "max_examine_rounds": 3,
+  "description": "Build a change against RED laws that are ALREADY committed, reviewed and sequenced, and loop until the verify seat's run says green or the rounds are spent. The entry types are the change-request, which names the commit holding the laws, and a change-plan (typically sealed by spec-review-and-sequence-v0). It is for the case software-change-pr-v1 cannot take: that loop always re-drafts laws, and its builder cannot run them. Attest: a read-only seat seals the committed laws from git, never from the working tree, so every amend round re-seals the same text. Build: a seat writes src/** and docs/**, runs the laws and tsc as it goes, and holds no tests/** grant. Verify: change-verifier runs the checks and compares every sealed law against the tree, so a weakened law fails the verdict. A failing verdict re-runs the builder with the verdict fed back, up to max_examine_rounds. It does not publish: the operator reviews the working tree and commits. An amend round re-runs only the builder: the attester's record from the failing round stays its input (contract-amend-nearest-makers-v1). Known limit: `tests/**` is excluded from the builder by allow scoping, not by explicit denial, so the verifier's weakened-law check is the enforcing backstop.",
+  "reserve_pool": 40
+}

package/standards/draft-red-laws-v0.json

@@ -0,0 +1,68 @@
+{
+  "slug": "draft-red-laws-v0",
+  "domain": "spec-drafting",
+  "agent_slugs": [
+    "red-spec-drafter",
+    "red-law-reviewer"
+  ],
+  "phases": [
+    {
+      "name": "draft-laws",
+      "chairs": [
+        {
+          "role": "draft-laws",
+          "agent_slug": "red-spec-drafter",
+          "depends_on": [],
+          "input_contract": [
+            "subsystem-contract"
+          ],
+          "output_contract": [
+            "red-spec"
+          ],
+          "required_skills": [],
+          "turn_reserve": 16,
+          "prime": {
+            "area": "coltrane-engine"
+          },
+          "fork_from": {
+            "primer": "coltrane-engine",
+            "max_context_tokens": 150000
+          }
+        }
+      ]
+    },
+    {
+      "name": "review-laws",
+      "chairs": [
+        {
+          "role": "review-laws",
+          "agent_slug": "red-law-reviewer",
+          "depends_on": [
+            "draft-laws"
+          ],
+          "input_contract": [
+            "subsystem-contract",
+            "red-spec"
+          ],
+          "output_contract": [
+            "change-verdict"
+          ],
+          "required_skills": [],
+          "turn_reserve": 8
+        }
+      ]
+    }
+  ],
+  "status": "draft",
+  "input_types": [
+    "subsystem-contract",
+    "change-request"
+  ],
+  "output_types": [
+    "red-spec",
+    "change-verdict"
+  ],
+  "max_examine_rounds": 2,
+  "description": "Draft RED laws for a contract the operator has ALREADY decided, and have them reviewed by a seat that runs them, without publishing anything. The entry types are a subsystem-contract (obligations, invariants with how each is checkable, failure modes) and a change-request naming the existing law files the contract supersedes. Draft: red-spec-drafter writes a real test for every invariant and failure mode into tests/** and the argued half into docs/specs/**, rewrites the superseded laws, runs them, watches them fail, and seals a red-spec from `git diff --cached`. Review: red-law-reviewer RUNS every law and reads every file. It fails the verdict on an uncovered item, a skipped path the request asked for, a patch that does not match the staged tree, a law that is not observed red for the contract's reason, a test that could never fail, or a removed out-of-concern law. A failing review goes back to the drafter, up to max_examine_rounds. It does not publish: the operator commits the laws and adjusts the pinned law counts, then builds them with build-from-red-spec-v0. v0 first seated spec-reviewer, which holds no tools and so could never observe redness (gig 6ed46423); this composition replaces it.",
+  "reserve_pool": 30
+}