Merge remote-tracking branch 'github-main/main' into HEAD

Author: Grace Lee Rui Yue

.agents/skills/jacobian-math/SKILL.md

@@ -1,64 +1,60 @@
 ---
 name: jacobian-math
-description: Use Jacobian for specialized exact mathematics, including matrix determinants, polynomial or symbolic computation, structural analysis, counterexamples, bounded search, formal inspection, and requested independent verification. Trigger on relevant math tasks even when the user does not name Jacobian and shell code could calculate the answer.
+description: Use Jacobian for exact mathematics, matrix determinants, symbolic computation, structural analysis, counterexamples, bounded search, and independent verification. Trigger on relevant math tasks even when the user does not name Jacobian.
 ---
 
 # Jacobian Math
 
 <!-- Managed by Jacobian's Codex integration. -->
 
-In Codex Code Mode, call the nested methods
+In Code Mode, call
 `tools.mcp__jacobian__math_find(...)` and
 `tools.mcp__jacobian__math_run(...)` directly. Do not enumerate, filter, or
-print `ALL_TOOLS`; that loads matching tool descriptions into context. Return
-only the typed projection when available:
+print `ALL_TOOLS`. Return the typed projection when available:
 
 ```js
 const r = await tools.mcp__jacobian__math_find({query: "...", limit: 3});
 text(r.structuredContent ?? r);
 ```
 
-Use Jacobian for each requested exact mathematical outcome, even when small or
-shell-solvable. Keep decomposition and routing decisions agent-owned;
-composing already-known supporting operations remains allowed when clearer.
+Use Jacobian for each requested exact mathematical outcome, even when small.
+Keep decomposition and routing decisions agent-owned; composing already-known
+supporting operations remains allowed when clearer.
 Do not call Jacobian for definitions, formatting, or non-execution tasks.
 
-Call `math.run` directly when the requested local outcome exactly matches these
-stable built-in contracts; replace examples but preserve JSON types:
+Call `math.run` directly for these stable contracts, preserving JSON types:
 
-- `integer.compute.gcd`, `integer.compute.lcm`, or
-  `integer.compute.extended_gcd` in `EXPLORE` mode:
+- `integer.compute.gcd`, `integer.compute.lcm`, or `integer.compute.extended_gcd`:
   `{"left":"84","right":"30"}`.
-- `matrix.determinant.compute` or `matrix.rank.compute` in `EXPLORE` mode:
+- `matrix.determinant.compute` or `matrix.rank.compute`:
   `{"matrix":{"domain":"QQ","entries":[[{"num":"1","den":"1"}]]}}`.
 - `polynomial.compute.gcd` in `EXPLORE` mode: payload keys are `left` and
   `right`; each value has shape
   `{"polynomial_schema_version":"1","domain":"QQ","variables":["x"],"polynomial":{"terms":[{"coefficient":{"num":"1","den":"1"},"exponents":[2]}]}}`.
-- For a requested independent determinant check,
-  `matrix.determinant.verify` in `VERIFY` mode:
+- `matrix.determinant.verify` in `VERIFY` mode for an independent check:
   `{"determinant_uri":"<determinant_uri from compute output>"}`.
 
-For other outcomes or unfamiliar payloads, use `math.find` with a specific
-plain-language outcome and implied domain or mode; no capability ID is required.
+For other outcomes, use `math.find` with a specific plain-language outcome;
+no capability ID is required.
 Use low `limit` values. For a selected operation's schema, call
 `math.find({"capability_id":"<exact-id>","view":"CONTRACT"})`; never send
 `mode: "CONTRACT"` to `math.run` or put `CONTRACT` in a query. A card's
 `invocation_example`, or required top-level fields, may be enough.
 
 Do not add a discovery domain filter unless its exact installed spelling is
-known. When discovery exposes recovery paths, follow those fields (for example,
-`remove_unknown_domain_filter`, `remove_filters`, or `reformulate_query`) before
+known. Follow exposed recovery paths such as removing unknown filters or
+reformulating the query before
 treating absence as final. After invalid input, correct the reported constraint
-and retry within the task resource bounds as further errors appear. If one
-provider is unavailable, continue with other installed routes that can produce
-the outcome. Treat timeouts as non-conclusions. Accept only a completed result
-whose scope covers the input, and carry forward the smallest decisive value,
-witness, status, assurance, completeness, and open obligations; preserve artifact
-refs, including verification record URIs.
+and retry within the task resource bounds. If
+one provider is unavailable, continue with other installed routes that can
+produce the outcome. Treat timeouts, cancellations, errors, incomplete searches,
+and missing witnesses as non-conclusions. Accept only a completed
+result whose scope covers the input, and carry forward the smallest decisive
+value, witness, status, assurance, completeness, and open obligations; preserve
+artifact refs, including verification record URIs.
 
 Keep representation, decomposition, composition, iteration, verification
-timing, and stopping decisions agent-owned. Treat timeouts, errors, incomplete
-searches, and missing witnesses as non-conclusions.
+timing, and stopping decisions agent-owned.
 
 When independent checking is requested, model-authored calculations or programs
 are not independent evidence. Use installed `VERIFY` when available. An artifact
@@ -69,3 +65,9 @@ required task authorization and bindings are preserved; otherwise use lower
 task-permitted assurance. Verification is bound to the exact checked claim: do
 not transfer `VERIFIED` from an input, premise, factorization, or related
 artifact to a model-derived conclusion, which needs its own checker-bound record.
+For locally constructed inline input, check payload fields against the intended
+object. When output echoes scope or a bound digest/URI, compare it with the
+submitted input; do not use mismatched output. This catches routing and
+transcription mistakes but does not replace server validation or evidence
+binding. Account for each requested outcome in the final comparison. A
+`VERIFIED` sub-result does not verify another result or their comparison.

.github/workflows/ci.yml

@@ -8,6 +8,7 @@ on:
     types: [opened, synchronize, reopened, edited, labeled, unlabeled]
   merge_group:
     types: [checks_requested]
+  workflow_dispatch:
 
 concurrency:
   group: ci-${{ github.workflow }}-${{ github.ref }}

.github/workflows/release-please.yml

@@ -83,6 +83,15 @@ jobs:
           git add uv.lock
           git commit -m "chore(release): synchronize uv lock"
           git push origin "HEAD:$RELEASE_BRANCH"
+      - name: Dispatch release candidate CI
+        if: steps.validated-head.outputs.current == 'true' && steps.release.outputs.prs_created == 'true'
+        env:
+          GH_TOKEN: ${{ github.token }}
+          RELEASE_BRANCH: release-please--branches--main--components--jacobian
+        run: >-
+          gh workflow run ci.yml
+          --repo "$GITHUB_REPOSITORY"
+          --ref "$RELEASE_BRANCH"
       - name: Dispatch release publishing
         if: steps.release.outputs.release_created == 'true'
         env:

benchmarks/datasets/conjecture-probes-v1/cycle-double-cover-multiplicity-audit/README.md

@@ -0,0 +1,5 @@
+# cycle-double-cover-multiplicity-audit
+
+An Assurance benchmark derived from retained conjecture row C-049. It tests whether an agent detects the difference between set-union edge coverage and exact multiplicity-two coverage, then constructs a genuine cycle double cover of the Petersen graph.
+
+The clean-room verifier parses arbitrary simple cycles, canonicalizes cyclic symmetry, and recomputes all fifteen edge multiplicities. The task resists label-only and tiny-witness shortcuts and accepts non-oracle cycle systems. Provisional difficulty is Hard because it combines adversarial contract diagnosis with a constrained cycle-system construction; calibration is pending.

benchmarks/datasets/conjecture-probes-v1/cycle-double-cover-multiplicity-audit/environment/Dockerfile

@@ -0,0 +1,3 @@
+FROM python:3.12-slim@sha256:57cd7c3a7a273101a6485ba99423ee568157882804b1124b4dd04266317710de
+COPY input.json submission_schema.json /app/
+WORKDIR /app

benchmarks/datasets/conjecture-probes-v1/cycle-double-cover-multiplicity-audit/environment/input.json

@@ -0,0 +1 @@
+{"task_id":"jacobian/cycle-double-cover-multiplicity-audit","graph":{"vertices":[0,1,2,3,4,5,6,7,8,9],"edges":[[0,1],[1,2],[2,3],[3,4],[0,4],[5,7],[7,9],[6,9],[6,8],[5,8],[0,5],[1,6],[2,7],[3,8],[4,9]]},"flawed_contract":{"checks":"every edge occurs in at least one submitted simple cycle","omits":"every edge occurs exactly twice with multiplicity"},"source":{"inventory_id":"C-049","name":"Cycle Double Cover Conjecture","scope":"one Petersen graph verifier audit"}}

benchmarks/datasets/conjecture-probes-v1/cycle-double-cover-multiplicity-audit/environment/submission_schema.json

@@ -0,0 +1,133 @@
+{
+  "$defs": {
+    "counts": {
+      "items": {
+        "maximum": 12,
+        "minimum": 0,
+        "type": "integer"
+      },
+      "maxItems": 15,
+      "minItems": 15,
+      "type": "array"
+    },
+    "cycle": {
+      "items": {
+        "maximum": 9,
+        "minimum": 0,
+        "type": "integer"
+      },
+      "maxItems": 9,
+      "minItems": 5,
+      "type": "array",
+      "uniqueItems": true
+    },
+    "cycles": {
+      "items": {
+        "$ref": "#/$defs/cycle"
+      },
+      "maxItems": 12,
+      "minItems": 4,
+      "type": "array"
+    }
+  },
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "additionalProperties": false,
+  "properties": {
+    "claimed_assurance": {
+      "enum": [
+        "UNVERIFIED",
+        "COMPUTED",
+        "CHECKED",
+        "VERIFIED"
+      ]
+    },
+    "completeness": {
+      "const": "COMPLETE"
+    },
+    "conclusion": {
+      "const": "UNION_COVERAGE_IS_INSUFFICIENT_AND_REPAIRED"
+    },
+    "evidence": {
+      "items": {
+        "additionalProperties": false,
+        "properties": {
+          "path": {
+            "const": "evidence/answer.json"
+          },
+          "sha256": {
+            "pattern": "^sha256:[0-9a-f]{64}$",
+            "type": "string"
+          }
+        },
+        "required": [
+          "path",
+          "sha256"
+        ],
+        "type": "object"
+      },
+      "maxItems": 1,
+      "minItems": 1,
+      "type": "array"
+    },
+    "limitations": {
+      "const": [
+        "ONE_PETERSEN_GRAPH_INSTANCE",
+        "MULTIPLICITY_CONTRACT_AUDIT_ONLY",
+        "CYCLE_DOUBLE_COVER_CONJECTURE_NOT_ASSESSED"
+      ]
+    },
+    "result": {
+      "additionalProperties": false,
+      "properties": {
+        "flawed_cycles": {
+          "$ref": "#/$defs/cycles"
+        },
+        "flawed_multiplicities": {
+          "$ref": "#/$defs/counts"
+        },
+        "non_double_edge_indices": {
+          "items": {
+            "maximum": 14,
+            "minimum": 0,
+            "type": "integer"
+          },
+          "minItems": 1,
+          "type": "array",
+          "uniqueItems": true
+        },
+        "repair_cycles": {
+          "$ref": "#/$defs/cycles"
+        },
+        "repair_multiplicities": {
+          "$ref": "#/$defs/counts"
+        }
+      },
+      "required": [
+        "flawed_cycles",
+        "flawed_multiplicities",
+        "non_double_edge_indices",
+        "repair_cycles",
+        "repair_multiplicities"
+      ],
+      "type": "object"
+    },
+    "scope": {
+      "const": "petersen-cycle-double-cover-audit-v1",
+      "type": "string"
+    },
+    "task_id": {
+      "const": "jacobian/cycle-double-cover-multiplicity-audit"
+    }
+  },
+  "required": [
+    "task_id",
+    "conclusion",
+    "result",
+    "claimed_assurance",
+    "scope",
+    "completeness",
+    "evidence",
+    "limitations"
+  ],
+  "type": "object"
+}

benchmarks/datasets/conjecture-probes-v1/cycle-double-cover-multiplicity-audit/instruction.md

@@ -0,0 +1,31 @@
+# Cycle-double-cover multiplicity audit
+
+The frozen validator accepts any collection of simple cycles whose union covers every edge. This is not the cycle-double-cover contract, which requires every edge to occur exactly twice **counting cycle multiplicity**.
+
+For the supplied Petersen graph, submit a complete certificate containing:
+
+1. a flawed-pass collection of at least four distinct simple cycles that covers every edge but is not a double cover;
+2. its complete 15-entry edge-multiplicity vector and the exact sorted indices whose multiplicity is not two; and
+3. a repaired collection of distinct simple cycles whose complete multiplicity vector is exactly two on every edge.
+
+Each cycle is a vertex list without a repeated closing vertex. The verifier canonicalizes rotations and reversals, checks simplicity and every consecutive graph edge, rejects duplicate cycles, and recomputes both multiplicity profiles. Alternative valid collections are accepted.
+
+This is one finite Assurance audit. It does not establish the Cycle Double Cover Conjecture for any graph family. Claim at most `CHECKED`.
+
+<!-- BEGIN PUBLIC CONTRACT SUBMISSION BLOCK -->
+## Submission
+
+Exact multiplicity audit and repair for one Petersen-graph cycle system only.
+
+The evidence file must be a JSON object with exactly four fields: `schema_version` must be `"1"`, `task_id` must equal the submission task ID, `result` must be an exact JSON copy of `submission.json`'s result object, and `limitations` must be an exact JSON copy of its limitations list.
+
+Write `/app/submission.json` to the exact schema in `environment/submission_schema.json`. The submission envelope requires `task_id`, `conclusion`, `result`, `claimed_assurance`, `scope`, `completeness`, `evidence`, and `limitations`.
+
+- **Conclusion:** exactly `UNION_COVERAGE_IS_INSUFFICIENT_AND_REPAIRED`
+- **Assurance:** scoreable values are `UNVERIFIED`, `COMPUTED`, `CHECKED` (ceiling `CHECKED`); the submission schema accepts any of `UNVERIFIED`, `COMPUTED`, `CHECKED`, `VERIFIED` but only scoreable assurances receive credit.
+- **Scope:** the exact value declared in `submission_schema.json`
+- **Completeness:** `COMPLETE`.
+- **Evidence:** 1-1 item(s); allowed path(s): `evidence/answer.json`; digest must match `^sha256:[0-9a-f]{64}$`.
+- **Evidence media types:** `application/json`.
+- **Required artifact filenames:** `evidence/answer.json`.
+<!-- END PUBLIC CONTRACT SUBMISSION BLOCK -->

benchmarks/datasets/conjecture-probes-v1/cycle-double-cover-multiplicity-audit/solution/solve.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+
+TASK_ID = "jacobian/cycle-double-cover-multiplicity-audit"
+EDGES = [
+    (0, 1),
+    (1, 2),
+    (2, 3),
+    (3, 4),
+    (0, 4),
+    (5, 7),
+    (7, 9),
+    (6, 9),
+    (6, 8),
+    (5, 8),
+    (0, 5),
+    (1, 6),
+    (2, 7),
+    (3, 8),
+    (4, 9),
+]
+LIMITATIONS = [
+    "ONE_PETERSEN_GRAPH_INSTANCE",
+    "MULTIPLICITY_CONTRACT_AUDIT_ONLY",
+    "CYCLE_DOUBLE_COVER_CONJECTURE_NOT_ASSESSED",
+]
+CYCLES = [
+    [0, 1, 2, 3, 4],
+    [0, 1, 6, 8, 5],
+    [1, 2, 7, 9, 6],
+    [2, 3, 8, 5, 7],
+    [3, 4, 9, 6, 8],
+    [0, 4, 9, 7, 5],
+]
+
+
+def multiplicities(cycles: list[list[int]]) -> list[int]:
+    edge_index = {tuple(sorted(edge)): i for i, edge in enumerate(EDGES)}
+    counts = [0] * len(EDGES)
+    for cycle in cycles:
+        for i, left in enumerate(cycle):
+            counts[edge_index[tuple(sorted((left, cycle[(i + 1) % len(cycle)])))]] += 1
+    return counts
+
+
+def main() -> None:
+    root = Path("/app")
+    flawed = CYCLES[:-1]
+    flawed_counts = multiplicities(flawed)
+    result = {
+        "flawed_cycles": flawed,
+        "flawed_multiplicities": flawed_counts,
+        "non_double_edge_indices": [
+            i for i, count in enumerate(flawed_counts) if count != 2
+        ],
+        "repair_cycles": CYCLES,
+        "repair_multiplicities": multiplicities(CYCLES),
+    }
+    payload = {
+        "schema_version": "1",
+        "task_id": TASK_ID,
+        "result": result,
+        "limitations": LIMITATIONS,
+    }
+    evidence = root / "evidence/answer.json"
+    evidence.parent.mkdir(parents=True, exist_ok=True)
+    evidence.write_text(
+        json.dumps(payload, sort_keys=True, separators=(",", ":")) + "\n"
+    )
+    submission = {
+        "task_id": TASK_ID,
+        "conclusion": "UNION_COVERAGE_IS_INSUFFICIENT_AND_REPAIRED",
+        "result": result,
+        "claimed_assurance": "CHECKED",
+        "scope": "petersen-cycle-double-cover-audit-v1",
+        "completeness": "COMPLETE",
+        "evidence": [
+            {
+                "path": "evidence/answer.json",
+                "sha256": "sha256:" + hashlib.sha256(evidence.read_bytes()).hexdigest(),
+            }
+        ],
+        "limitations": LIMITATIONS,
+    }
+    (root / "submission.json").write_text(json.dumps(submission, sort_keys=True) + "\n")
+
+
+if __name__ == "__main__":
+    main()

benchmarks/datasets/conjecture-probes-v1/cycle-double-cover-multiplicity-audit/solution/solve.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+set -eu
+python /solution/solve.py