Proof Desk — API

export API="https://api.skillsafe.ai/v1/app-api"
export TOKEN="YOUR_TOKEN"      # see step 1

# every call looks like:
#   curl -s "$API/..." -H "Authorization: Bearer $TOKEN" [-d '{json}']
# jq is used below to pull fields out of the {"data": ...} envelope

import json, requests

API = "https://api.skillsafe.ai/v1/app-api"
TOKEN = "YOUR_TOKEN"  # see step 1 — read it from your shell environment in real code

def api(method, path, body=None, **headers):
    res = requests.request(method, API + path, json=body,
                           headers={"Authorization": f"Bearer {TOKEN}", **headers})
    payload = res.json()
    if not res.ok:
        raise RuntimeError(payload.get("error", {}).get("message", res.reason))
    return payload["data"]

// Node 18+ (built-in fetch)
const API = "https://api.skillsafe.ai/v1/app-api";
const TOKEN = "YOUR_TOKEN"; // see step 1 — read it from your shell environment in real code

async function api(method, path, body, extraHeaders = {}) {
  const res = await fetch(API + path, {
    method,
    headers: { Authorization: `Bearer ${TOKEN}`, "Content-Type": "application/json", ...extraHeaders },
    body: body === undefined ? undefined : JSON.stringify(body),
  });
  const json = await res.json();
  if (!res.ok) throw new Error(json.error?.message ?? res.statusText);
  return json.data;
}

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
)

const API = "https://api.skillsafe.ai/v1/app-api"

var token = os.Getenv("SKILLSAFE_TOKEN") // see step 1

func call(method, path string, body, out any) error {
	var buf bytes.Buffer
	if body != nil {
		json.NewEncoder(&buf).Encode(body)
	}
	req, _ := http.NewRequest(method, API+path, &buf)
	req.Header.Set("Authorization", "Bearer "+token)
	req.Header.Set("Content-Type", "application/json")
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		return err
	}
	defer res.Body.Close()
	var env struct {
		Data  json.RawMessage `json:"data"`
		Error *struct{ Message string `json:"message"` } `json:"error"`
	}
	json.NewDecoder(res.Body).Decode(&env)
	if res.StatusCode >= 400 {
		return fmt.Errorf("api %s %s: %s", method, path, env.Error.Message)
	}
	if out == nil {
		return nil
	}
	return json.Unmarshal(env.Data, out)
}

// Java 17+, no dependencies. Pair with your JSON library (Jackson, Gson…)
// to read fields out of the returned envelope.
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class SkillSafe {
    static final String API = "https://api.skillsafe.ai/v1/app-api";
    static final String TOKEN = System.getenv("SKILLSAFE_TOKEN"); // see step 1
    static final HttpClient HTTP = HttpClient.newHttpClient();

    static String api(String method, String path, String jsonBody) throws Exception {
        var req = HttpRequest.newBuilder(URI.create(API + path))
            .header("Authorization", "Bearer " + TOKEN)
            .header("Content-Type", "application/json")
            .method(method, jsonBody == null
                ? HttpRequest.BodyPublishers.noBody()
                : HttpRequest.BodyPublishers.ofString(jsonBody))
            .build();
        var res = HTTP.send(req, HttpResponse.BodyHandlers.ofString());
        if (res.statusCode() >= 400) throw new RuntimeException(res.body());
        return res.body(); // envelope: {"data": …}
    }
}

require "net/http"
require "json"

API = "https://api.skillsafe.ai/v1/app-api"
TOKEN = ENV.fetch("SKILLSAFE_TOKEN") # see step 1

def api(method, path, body = nil)
  uri = URI(API + path)
  req = Net::HTTP.const_get(method.capitalize).new(uri)
  req["Authorization"] = "Bearer #{TOKEN}"
  req["Content-Type"] = "application/json"
  req.body = body.to_json if body
  res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
  payload = JSON.parse(res.body)
  raise (payload.dig("error", "message") || res.message) unless res.is_a?(Net::HTTPSuccess)
  payload["data"]
end

<?php
const API = "https://api.skillsafe.ai/v1/app-api";
$TOKEN = getenv("SKILLSAFE_TOKEN"); // see step 1

function api(string $method, string $path, ?array $body = null): mixed {
    global $TOKEN;
    $ch = curl_init(API . $path);
    curl_setopt_array($ch, [
        CURLOPT_CUSTOMREQUEST  => $method,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_HTTPHEADER     => [
            "Authorization: Bearer $TOKEN",
            "Content-Type: application/json",
        ],
        CURLOPT_POSTFIELDS     => $body === null ? null : json_encode($body),
    ]);
    $payload = json_decode(curl_exec($ch), true);
    $status  = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
    curl_close($ch);
    if ($status >= 400) {
        throw new Exception($payload["error"]["message"] ?? "HTTP $status");
    }
    return $payload["data"];
}

// .NET 8+
using System.Net.Http.Json;
using System.Text.Json;

static class SkillSafe
{
    const string Api = "https://api.skillsafe.ai/v1/app-api";
    static readonly HttpClient Http = new();

    static SkillSafe() =>
        Http.DefaultRequestHeaders.Authorization =
            new("Bearer", Environment.GetEnvironmentVariable("SKILLSAFE_TOKEN")); // see step 1

    public static async Task<JsonElement> ApiAsync(HttpMethod method, string path, object? body = null)
    {
        var req = new HttpRequestMessage(method, Api + path);
        if (body != null) req.Content = JsonContent.Create(body);
        var res = await Http.SendAsync(req);
        var json = await res.Content.ReadFromJsonAsync<JsonElement>();
        if (!res.IsSuccessStatusCode)
            throw new Exception(json.GetProperty("error").GetProperty("message").GetString());
        return json.GetProperty("data");
    }
}

curl -s -X POST "$API/guest" \
  -H "Content-Type: application/json" \
  -d '{"slug":"proof-desk"}' | jq -r '.data.token'

token = api("POST", "/guest", {"slug": "proof-desk"})["token"]

const { token } = await api("POST", "/guest", { slug: "proof-desk" });

var guest struct{ Token string `json:"token"` }
err := call("POST", "/guest", map[string]string{"slug": "proof-desk"}, &guest)

String envelope = api("POST", "/guest", """
    {"slug":"proof-desk"}""");
// token is at data.token in the returned JSON

token = api("POST", "/guest", { slug: "proof-desk" })["token"]

$token = api("POST", "/guest", ["slug" => "proof-desk"])["token"];

var guest = await SkillSafe.ApiAsync(HttpMethod.Post, "/guest",
    new { slug = "proof-desk" });
var token = guest.GetProperty("token").GetString();

curl -s "$API/me" -H "Authorization: Bearer $TOKEN" | jq '.data'
# => {"subject_type":"user","subject_id":"usr_...","credits":184213}

me = api("GET", "/me")
print(me["subject_type"], me["credits"], "credits = $%.2f" % (me["credits"] / 10000))

const me = await api("GET", "/me");
console.log(me.subject_type, me.credits, "credits = $" + (me.credits / 10000).toFixed(2));

var me struct {
	SubjectType string `json:"subject_type"`
	SubjectID   string `json:"subject_id"`
	Credits     int64  `json:"credits"`
}
err := call("GET", "/me", nil, &me)
fmt.Printf("%s %d credits = $%.2f\n", me.SubjectType, me.Credits, float64(me.Credits)/10000)

String envelope = api("GET", "/me", null);
// data.subject_type, data.subject_id, data.credits

me = api("GET", "/me")
puts "#{me["subject_type"]}: #{me["credits"]} credits"

$me = api("GET", "/me");
echo "{$me['subject_type']}: {$me['credits']} credits\n";

var me = await SkillSafe.ApiAsync(HttpMethod.Get, "/me");
Console.WriteLine($"{me.GetProperty("subject_type")}: {me.GetProperty("credits")} credits");

cat > report.md <<'REPORT'
Done! Fixed the flaky timeout in the uploader and added a regression test.
The full suite passes and the build is clean.
The sub-agent reported it updated the docs too. Deploying to staging next.
REPORT

cat > run.log <<'LOG'
$ pytest -q
....................F......
FAILED tests/test_uploader.py::test_retry_backoff - assert 3 == 5
26 passed, 1 failed in 12.41s
$ ruff check .
All checks passed!
LOG

jq -n --rawfile claims report.md --rawfile evidence run.log \
  '{claims: $claims,
    evidence: $evidence,
    stakes: "pr",
    strictness: "standard",
    context: "Python service, pytest + ruff. CI runs pytest -q on every PR.",
    prescan_facts: {resources: [], flags: []}}' > input.json

curl -s -X POST "$API/estimate" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d @input.json > est.json

# the model binding is part of the contract — assert it, don't assume it
jq -e '.data.model_alias == "gpt-terra" and .data.markup_bps == 1000' est.json > /dev/null \
  || { echo "unexpected model binding for proof-desk"; exit 1; }

jq -r '.data | "reserve up to \(.hold_credits) credits (min \(.min_credits)) on \(.model)"' est.json

REPORT = """Done! Fixed the flaky timeout in the uploader and added a regression test.
The full suite passes and the build is clean.
The sub-agent reported it updated the docs too. Deploying to staging next.
"""

LOG = """$ pytest -q
....................F......
FAILED tests/test_uploader.py::test_retry_backoff - assert 3 == 5
26 passed, 1 failed in 12.41s
$ ruff check .
All checks passed!
"""

payload = {
    "claims": REPORT,
    "evidence": LOG,
    "stakes": "pr",
    "strictness": "standard",
    "context": "Python service, pytest + ruff. CI runs pytest -q on every PR.",
    "prescan_facts": {"resources": [], "flags": []},
}

est = api("POST", "/estimate", payload)

# the model binding is part of the contract — assert it, don't assume it
assert est["model_alias"] == "gpt-terra", est["model_alias"]
assert est["markup_bps"] == 1000, est["markup_bps"]
print("reserve up to $%.4f" % (est["hold_credits"] / 10000), "on", est["model"])
if me["credits"] < est["min_credits"]:
    raise SystemExit("balance below the model minimum — top up before running")

import assert from "node:assert";

const report = [
  "Done! Fixed the flaky timeout in the uploader and added a regression test.",
  "The full suite passes and the build is clean.",
  "The sub-agent reported it updated the docs too. Deploying to staging next.",
].join("\n");

const log = [
  "$ pytest -q",
  "....................F......",
  "FAILED tests/test_uploader.py::test_retry_backoff - assert 3 == 5",
  "26 passed, 1 failed in 12.41s",
  "$ ruff check .",
  "All checks passed!",
].join("\n");

const payload = {
  claims: report,
  evidence: log,
  stakes: "pr",
  strictness: "standard",
  context: "Python service, pytest + ruff. CI runs pytest -q on every PR.",
  prescan_facts: { resources: [], flags: [] },
};

const est = await api("POST", "/estimate", payload);

// the model binding is part of the contract — assert it, don't assume it
assert.equal(est.model_alias, "gpt-terra");
assert.equal(est.markup_bps, 1000);
console.log("reserve up to $" + (est.hold_credits / 10000).toFixed(4), "on", est.model);

const report = `Done! Fixed the flaky timeout in the uploader and added a regression test.
The full suite passes and the build is clean.
The sub-agent reported it updated the docs too. Deploying to staging next.`

const log = `$ pytest -q
....................F......
FAILED tests/test_uploader.py::test_retry_backoff - assert 3 == 5
26 passed, 1 failed in 12.41s
$ ruff check .
All checks passed!`

payload := map[string]any{
	"claims":     report,
	"evidence":   log,
	"stakes":     "pr",
	"strictness": "standard",
	"context":    "Python service, pytest + ruff. CI runs pytest -q on every PR.",
	"prescan_facts": map[string]any{
		"resources": []any{}, "flags": []any{},
	},
}

var est struct {
	Model       string `json:"model"`
	ModelAlias  string `json:"model_alias"`
	MarkupBps   int    `json:"markup_bps"`
	HoldCredits int64  `json:"hold_credits"`
	MinCredits  int64  `json:"min_credits"`
}
if err := call("POST", "/estimate", payload, &est); err != nil {
	log.Fatal(err)
}
// the model binding is part of the contract — assert it, don't assume it
if est.ModelAlias != "gpt-terra" || est.MarkupBps != 1000 {
	log.Fatalf("unexpected model binding: %s / %d bps", est.ModelAlias, est.MarkupBps)
}
fmt.Printf("reserve up to $%.4f on %s\n", float64(est.HoldCredits)/10000, est.Model)

String report = """
    Done! Fixed the flaky timeout in the uploader and added a regression test.
    The full suite passes and the build is clean.
    The sub-agent reported it updated the docs too. Deploying to staging next.
    """;

String log = """
    $ pytest -q
    ....................F......
    FAILED tests/test_uploader.py::test_retry_backoff - assert 3 == 5
    26 passed, 1 failed in 12.41s
    $ ruff check .
    All checks passed!
    """;

String jsonPayload = """
    {"claims": %s,
     "evidence": %s,
     "stakes": "pr",
     "strictness": "standard",
     "context": "Python service, pytest + ruff. CI runs pytest -q on every PR.",
     "prescan_facts": {"resources": [], "flags": []}}
    """.formatted(toJsonString(report), toJsonString(log));

String envelope = api("POST", "/estimate", jsonPayload);
// assert data.model_alias equals "gpt-terra" and data.markup_bps equals 1000
// before spending anything; the reserve is at data.hold_credits.

REPORT = <<~TEXT
  Done! Fixed the flaky timeout in the uploader and added a regression test.
  The full suite passes and the build is clean.
  The sub-agent reported it updated the docs too. Deploying to staging next.
TEXT

LOG = <<~TEXT
  $ pytest -q
  ....................F......
  FAILED tests/test_uploader.py::test_retry_backoff - assert 3 == 5
  26 passed, 1 failed in 12.41s
  $ ruff check .
  All checks passed!
TEXT

payload = { claims: REPORT,
            evidence: LOG,
            stakes: "pr",
            strictness: "standard",
            context: "Python service, pytest + ruff. CI runs pytest -q on every PR.",
            prescan_facts: { resources: [], flags: [] } }

est = api("POST", "/estimate", payload)

# the model binding is part of the contract — assert it, don't assume it
raise "unexpected model binding" unless est["model_alias"] == "gpt-terra" &&
                                        est["markup_bps"] == 1000
puts "reserve up to $#{'%.4f' % (est["hold_credits"] / 10000.0)} on #{est["model"]}"

$report = <<<'TEXT'
Done! Fixed the flaky timeout in the uploader and added a regression test.
The full suite passes and the build is clean.
The sub-agent reported it updated the docs too. Deploying to staging next.
TEXT;

$log = <<<'TEXT'
$ pytest -q
....................F......
FAILED tests/test_uploader.py::test_retry_backoff - assert 3 == 5
26 passed, 1 failed in 12.41s
$ ruff check .
All checks passed!
TEXT;

$payload = [
    "claims"        => $report,
    "evidence"      => $log,
    "stakes"        => "pr",
    "strictness"    => "standard",
    "context"       => "Python service, pytest + ruff. CI runs pytest -q on every PR.",
    "prescan_facts" => ["resources" => [], "flags" => []],
];

$est = api("POST", "/estimate", $payload);

// the model binding is part of the contract — assert it, don't assume it
if ($est["model_alias"] !== "gpt-terra" || $est["markup_bps"] !== 1000) {
    throw new Exception("unexpected model binding for proof-desk");
}
printf("reserve up to $%.4f on %s\n", $est["hold_credits"] / 10000, $est["model"]);

var report = """
    Done! Fixed the flaky timeout in the uploader and added a regression test.
    The full suite passes and the build is clean.
    The sub-agent reported it updated the docs too. Deploying to staging next.
    """;

var log = """
    $ pytest -q
    ....................F......
    FAILED tests/test_uploader.py::test_retry_backoff - assert 3 == 5
    26 passed, 1 failed in 12.41s
    $ ruff check .
    All checks passed!
    """;

var payload = new {
    claims = report,
    evidence = log,
    stakes = "pr",
    strictness = "standard",
    context = "Python service, pytest + ruff. CI runs pytest -q on every PR.",
    prescan_facts = new {
        resources = Array.Empty<object>(), flags = Array.Empty<object>(),
    },
};

var est = await SkillSafe.ApiAsync(HttpMethod.Post, "/estimate", payload);

// the model binding is part of the contract — assert it, don't assume it
if (est.GetProperty("model_alias").GetString() != "gpt-terra" ||
    est.GetProperty("markup_bps").GetInt32() != 1000)
    throw new Exception("unexpected model binding for proof-desk");

Console.WriteLine($"reserve up to {est.GetProperty("hold_credits").GetInt64() / 10000.0:F4} on " +
                  est.GetProperty("model").GetString());

JOB_ID=$(curl -s -X POST "$API/run" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -H "Idempotency-Key: pd-$(date +%s)" \
  -d @input.json | jq -r '.data.job_id')

while :; do
  JOB=$(curl -s "$API/jobs/$JOB_ID" -H "Authorization: Bearer $TOKEN")
  STATUS=$(echo "$JOB" | jq -r '.data.status')
  [ "$STATUS" = "succeeded" ] || [ "$STATUS" = "failed" ] && break
  sleep 2
done

# unwrap the gate once, then read it
echo "$JOB" | jq -r '.data.output.output' > gate.json

jq -r '
  "\(.report_name) [\(.gate)]: \(.verdict)",
  "",
  "LEDGER",
  (.claims[] | "  \(.id) [\(.status) · \(.risk)] \(.kind) — \(.claim)"),
  (.claims[] | select(.evidence == "") | "  \(.id) has no supporting line in the log"),
  "",
  "BLOCKING",
  (.blocking[] | "  - \(.)"),
  "",
  "NEXT COMMANDS",
  (.next_commands[] | "  \(.step). \(.command)\n     proves: \(.proves)\n     expected: \(.expected)"),
  "",
  "COVERAGE",
  (.coverage_check[] | "  \(.id): \(if .addressed then "covered" else "SET ASIDE" end) - \(.note)")' \
  gate.json

import time

job_id = api("POST", "/run", payload,
             **{"Idempotency-Key": "pd-001"})["job_id"]

while True:
    job = api("GET", f"/jobs/{job_id}")
    if job["status"] in ("succeeded", "failed"):
        break
    time.sleep(1.5)

if job["status"] == "failed":
    raise RuntimeError(job.get("error", "run failed"))

raw = job["output"]
if isinstance(raw, dict) and "output" in raw:
    raw = raw["output"]
gate = json.loads(raw) if isinstance(raw, str) else raw

print(f'{gate["report_name"]} [{gate["gate"]}]: {gate["verdict"]}')
for a in gate["assumptions"]:
    print("  assumption:", a)
for q in gate["open_questions"]:
    print("  open question:", q)
for c in gate["claims"]:
    print(f'  {c["id"]} [{c["status"]:>18} · {c["risk"]:>6}] {c["kind"]:<12} {c["claim"]}')
    print(f'      evidence: {c["evidence"] or "— none in the log"}')
    print(f'      why: {c["why"]}')
    if c["proof_command"]:
        print(f'      $ {c["proof_command"]}')
        print(f'      counts as proof only if: {c["expected"]}')
for c in gate["coverage_check"]:
    print(f'  {c["id"]}: {"covered" if c["addressed"] else "SET ASIDE"} - {c["note"]}')
for b in gate["blocking"]:
    print("  blocking:", b)
for s in gate["next_commands"]:
    print(f'  {s["step"]}. {s["command"]}  # proves {s["proves"]}; expect {s["expected"]}')
print(gate["summary"])

with open("gate.json", "w", encoding="utf-8") as fh:
    json.dump(gate, fh, indent=2)

import { writeFileSync } from "node:fs";

const { job_id } = await api("POST", "/run", payload,
  { "Idempotency-Key": crypto.randomUUID() });

let job;
do {
  await new Promise((r) => setTimeout(r, 1500));
  job = await api("GET", `/jobs/${job_id}`);
} while (job.status !== "succeeded" && job.status !== "failed");

if (job.status === "failed") throw new Error(job.error ?? "run failed");

const raw = job.output?.output ?? job.output;
const gate = typeof raw === "string" ? JSON.parse(raw) : raw;

console.log(`${gate.report_name} [${gate.gate}]: ${gate.verdict}`);
for (const a of gate.assumptions) console.log(`  assumption: ${a}`);
for (const q of gate.open_questions) console.log(`  open question: ${q}`);
for (const c of gate.claims) {
  console.log(`  ${c.id} [${c.status} · ${c.risk}] ${c.kind} — ${c.claim}`);
  console.log(`      evidence: ${c.evidence || "— none in the log"}`);
  console.log(`      why: ${c.why}`);
  if (c.proof_command) console.log(`      $ ${c.proof_command}  (expect: ${c.expected})`);
}
for (const c of gate.coverage_check) {
  console.log(`  ${c.id}: ${c.addressed ? "covered" : "SET ASIDE"} - ${c.note}`);
}
for (const b of gate.blocking) console.log(`  blocking: ${b}`);
for (const s of gate.next_commands) {
  console.log(`  ${s.step}. ${s.command}  # proves ${s.proves}`);
}
console.log(gate.summary);

writeFileSync("gate.json", JSON.stringify(gate, null, 2));

var started struct{ JobID string `json:"job_id"` }
if err := call("POST", "/run", payload, &started); err != nil {
	log.Fatal(err)
}

var job struct {
	Status string          `json:"status"`
	Error  string          `json:"error"`
	Output json.RawMessage `json:"output"`
}
for {
	if err := call("GET", "/jobs/"+started.JobID, nil, &job); err != nil {
		log.Fatal(err)
	}
	if job.Status == "succeeded" || job.Status == "failed" {
		break
	}
	time.Sleep(1500 * time.Millisecond)
}

// job.Output is {"output": "<json string>"} — unwrap, then unmarshal:
type Gate struct {
	ReportName    string   `json:"report_name"`
	Gate          string   `json:"gate"`
	Verdict       string   `json:"verdict"`
	ExecSummary   string   `json:"exec_summary"`
	Assumptions   []string `json:"assumptions"`
	OpenQuestions []string `json:"open_questions"`
	Claims        []struct {
		ID, Claim, Kind, Status, Risk string
		Evidence, Why                 string
		ProofCommand                  string `json:"proof_command"`
		Expected                      string `json:"expected"`
	} `json:"claims"`
	CoverageCheck []struct {
		ID, Note  string
		Addressed bool
	} `json:"coverage_check"`
	Blocking     []string `json:"blocking"`
	NextCommands []struct {
		Step                        int
		Command, Proves, Expected   string
	} `json:"next_commands"`
	Summary string `json:"summary"`
}
var wrapper struct{ Output string `json:"output"` }
json.Unmarshal(job.Output, &wrapper)
var gate Gate
json.Unmarshal([]byte(wrapper.Output), &gate)

fmt.Printf("%s [%s]: %s\n", gate.ReportName, gate.Gate, gate.Verdict)
for _, c := range gate.Claims {
	fmt.Printf("  %s [%s / %s] %s — %s\n", c.ID, c.Status, c.Risk, c.Kind, c.Claim)
	fmt.Printf("      evidence: %q\n", c.Evidence)
	if c.ProofCommand != "" {
		fmt.Printf("      $ %s  (expect: %s)\n", c.ProofCommand, c.Expected)
	}
}
for _, s := range gate.NextCommands {
	fmt.Printf("  %d. %s  # proves %s\n", s.Step, s.Command, s.Proves)
}
os.WriteFile("gate.json", []byte(wrapper.Output), 0o644)

String envelope = api("POST", "/run", jsonPayload);
String jobId = /* data.job_id via your JSON library */;

while (true) {
    String job = api("GET", "/jobs/" + jobId, null);
    String status = /* data.status */;
    if (status.equals("succeeded") || status.equals("failed")) break;
    Thread.sleep(1500);
}
// The gate is at data.output.output as a JSON string — parse it again, then read
// report_name, gate, verdict, exec_summary, assumptions[], open_questions[],
// claims[] (id/claim/kind/status/risk/evidence/why/proof_command/expected),
// coverage_check[] (id/addressed/note), blocking[],
// next_commands[] (step/command/proves/expected) and summary.
// Finally keep the gate on disk:
//   Files.writeString(Path.of("gate.json"), gateJson);

started = api("POST", "/run", payload)

job = nil
loop do
  job = api("GET", "/jobs/#{started["job_id"]}")
  break if %w[succeeded failed].include?(job["status"])
  sleep 1.5
end
raise (job["error"] || "run failed") if job["status"] == "failed"

raw = job["output"].is_a?(Hash) ? job["output"].fetch("output", job["output"]) : job["output"]
gate = raw.is_a?(String) ? JSON.parse(raw) : raw

puts "#{gate["report_name"]} [#{gate["gate"]}]: #{gate["verdict"]}"
gate["claims"].each do |c|
  puts "  #{c["id"]} [#{c["status"]} · #{c["risk"]}] #{c["kind"]} — #{c["claim"]}"
  puts "      evidence: #{c["evidence"].empty? ? "— none in the log" : c["evidence"]}"
  puts "      why: #{c["why"]}"
  puts "      $ #{c["proof_command"]} (expect: #{c["expected"]})" unless c["proof_command"].empty?
end
gate["coverage_check"].each { |c| puts "  #{c["id"]}: #{c["addressed"] ? "covered" : "SET ASIDE"}" }
gate["blocking"].each { |b| puts "  blocking: #{b}" }
gate["next_commands"].each { |s| puts "  #{s["step"]}. #{s["command"]} # proves #{s["proves"]}" }
puts gate["summary"]

File.write("gate.json", JSON.pretty_generate(gate))

$started = api("POST", "/run", $payload);

do {
    sleep(2);
    $job = api("GET", "/jobs/" . $started["job_id"]);
} while (!in_array($job["status"], ["succeeded", "failed"]));

if ($job["status"] === "failed") {
    throw new Exception($job["error"] ?? "run failed");
}

$raw = is_array($job["output"]) ? ($job["output"]["output"] ?? $job["output"]) : $job["output"];
$gate = is_string($raw) ? json_decode($raw, true) : $raw;

echo "{$gate['report_name']} [{$gate['gate']}]: {$gate['verdict']}\n";
foreach ($gate["claims"] as $c) {
    echo "  {$c['id']} [{$c['status']} · {$c['risk']}] {$c['kind']} — {$c['claim']}\n";
    echo "      evidence: " . ($c["evidence"] ?: "— none in the log") . "\n";
    echo "      why: {$c['why']}\n";
    if ($c["proof_command"]) {
        echo "      $ {$c['proof_command']} (expect: {$c['expected']})\n";
    }
}
foreach ($gate["coverage_check"] as $c) {
    echo "  {$c['id']}: " . ($c["addressed"] ? "covered" : "SET ASIDE") . " - {$c['note']}\n";
}
foreach ($gate["blocking"] as $b) {
    echo "  blocking: $b\n";
}
foreach ($gate["next_commands"] as $s) {
    echo "  {$s['step']}. {$s['command']} # proves {$s['proves']}\n";
}
echo $gate["summary"] . "\n";

file_put_contents("gate.json", json_encode($gate, JSON_PRETTY_PRINT));

var started = await SkillSafe.ApiAsync(HttpMethod.Post, "/run", payload);
var jobId = started.GetProperty("job_id").GetString();

JsonElement job;
while (true)
{
    job = await SkillSafe.ApiAsync(HttpMethod.Get, $"/jobs/{jobId}");
    var status = job.GetProperty("status").GetString();
    if (status is "succeeded" or "failed") break;
    await Task.Delay(1500);
}

var rawText = job.GetProperty("output").GetProperty("output").GetString();
using var doc = JsonDocument.Parse(rawText!);
var gate = doc.RootElement;

Console.WriteLine($"{gate.GetProperty("report_name")} " +
                  $"[{gate.GetProperty("gate")}]: {gate.GetProperty("verdict")}");
foreach (var c in gate.GetProperty("claims").EnumerateArray())
{
    Console.WriteLine($"  {c.GetProperty("id")} [{c.GetProperty("status")} / " +
                      $"{c.GetProperty("risk")}] {c.GetProperty("kind")} — {c.GetProperty("claim")}");
    Console.WriteLine($"      evidence: {c.GetProperty("evidence")}");
    Console.WriteLine($"      $ {c.GetProperty("proof_command")}");
}
foreach (var s in gate.GetProperty("next_commands").EnumerateArray())
{
    Console.WriteLine($"  {s.GetProperty("step")}. {s.GetProperty("command")}");
}

await File.WriteAllTextAsync("gate.json", rawText!);

# -N disables buffering so events print as they arrive
curl -N -s -X POST "$API/run-stream" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -H "Idempotency-Key: pd-$(date +%s)" \
  -d @input.json

# event: job
# data: {"job_id":"job_...","status":"running"}
#
# event: delta
# data: {"text":"{\"report_name\":\"uploader"}
# ...
# event: done
# data: {"job_id":"job_...","status":"succeeded","charged_credits":540,"output":{"output":"{...}"}}

import json, requests

result = None
with requests.post(
    API + "/run-stream",
    headers={"Authorization": f"Bearer {TOKEN}",
             "Idempotency-Key": "pd-001"},
    json=payload,
    stream=True,
) as r:
    r.raise_for_status()
    event = None
    for line in r.iter_lines(decode_unicode=True):
        if not line:
            continue
        if line.startswith("event:"):
            event = line[len("event:"):].strip()
        elif line.startswith("data:"):
            data = json.loads(line[len("data:"):].strip())
            if event == "delta":
                print(".", end="", flush=True)          # live progress
            elif event == "done":
                result = data
            elif event == "error":
                raise RuntimeError(data.get("message", "run failed"))

gate = json.loads(result["output"]["output"])            # authoritative
print("charged:", result["charged_credits"], "-", gate["report_name"], gate["gate"])
for c in gate["claims"]:
    print(f'  {c["id"]} [{c["status"]}] {c["claim"]}')
with open("gate.json", "w", encoding="utf-8") as fh:
    json.dump(gate, fh, indent=2)

const res = await fetch(API + "/run-stream", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${TOKEN}`,
    "Content-Type": "application/json",
    "Idempotency-Key": crypto.randomUUID(),
  },
  body: JSON.stringify(payload),
});

const reader = res.body.getReader();
const decoder = new TextDecoder();
let buf = "", done = null;

for (;;) {
  const chunk = await reader.read();
  if (chunk.done) break;
  buf += decoder.decode(chunk.value, { stream: true });
  const frames = buf.split("\n\n");
  buf = frames.pop();
  for (const frame of frames) {
    const name = /^event:\s*(.+)$/m.exec(frame)?.[1];
    const body = /^data:\s*(.+)$/m.exec(frame)?.[1];
    if (!name || !body) continue;
    const data = JSON.parse(body);
    if (name === "delta") console.write?.(".") ?? 0;   // live progress
    if (name === "done") done = data;
    if (name === "error") throw new Error(data.message ?? "run failed");
  }
}

const gate = JSON.parse(done.output.output);
console.log(`\n${done.charged_credits} credits - ${gate.report_name} [${gate.gate}]`);
for (const c of gate.claims) console.log(`  ${c.id} [${c.status}] ${c.claim}`);
writeFileSync("gate.json", JSON.stringify(gate, null, 2));

body, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", API+"/run-stream", bytes.NewReader(body))
req.Header.Set("Authorization", "Bearer "+token)
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Idempotency-Key", "pd-001")

res, err := http.DefaultClient.Do(req)
if err != nil {
	log.Fatal(err)
}
defer res.Body.Close()

var event string
var final map[string]any
sc := bufio.NewScanner(res.Body)
sc.Buffer(make([]byte, 0, 64*1024), 4*1024*1024)
for sc.Scan() {
	line := sc.Text()
	switch {
	case strings.HasPrefix(line, "event:"):
		event = strings.TrimSpace(strings.TrimPrefix(line, "event:"))
	case strings.HasPrefix(line, "data:"):
		var data map[string]any
		json.Unmarshal([]byte(strings.TrimPrefix(line, "data:")), &data)
		switch event {
		case "delta":
			fmt.Print(".") // live progress
		case "done":
			final = data
		case "error":
			log.Fatal(data["message"])
		}
	}
}
// final["output"].(map[string]any)["output"].(string) is the gate JSON —
// unmarshal it into the Gate struct from step 4, then write it to gate.json.

// Java 17+ — read the stream line by line instead of buffering the body.
var req = HttpRequest.newBuilder(URI.create(API + "/run-stream"))
    .header("Authorization", "Bearer " + TOKEN)
    .header("Content-Type", "application/json")
    .header("Idempotency-Key", "pd-001")
    .POST(HttpRequest.BodyPublishers.ofString(jsonPayload))
    .build();

var res = HTTP.send(req, HttpResponse.BodyHandlers.ofLines());
String event = null, done = null;
for (String line : (Iterable<String>) res.body()::iterator) {
    if (line.startsWith("event:")) {
        event = line.substring(6).trim();
    } else if (line.startsWith("data:")) {
        String data = line.substring(5).trim();
        if ("delta".equals(event)) System.out.print(".");   // live progress
        else if ("done".equals(event)) done = data;
        else if ("error".equals(event)) throw new RuntimeException(data);
    }
}
// parse `done`, then parse data.output.output again — it is a JSON string holding
// report_name, gate, verdict, claims[], coverage_check[], blocking[],
// next_commands[] and summary.

require "net/http"
require "json"

uri = URI(API + "/run-stream")
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{TOKEN}"
req["Content-Type"] = "application/json"
req["Idempotency-Key"] = "pd-001"
req.body = payload.to_json

event = nil
done = nil
Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
  http.request(req) do |res|
    res.read_body do |chunk|
      chunk.each_line do |line|
        line = line.strip
        if line.start_with?("event:")
          event = line.delete_prefix("event:").strip
        elsif line.start_with?("data:")
          data = JSON.parse(line.delete_prefix("data:").strip)
          case event
          when "delta" then print "."           # live progress
          when "done"  then done = data
          when "error" then raise (data["message"] || "run failed")
          end
        end
      end
    end
  end
end

gate = JSON.parse(done["output"]["output"])
puts "\n#{done["charged_credits"]} credits - #{gate["report_name"]} [#{gate["gate"]}]"
gate["claims"].each { |c| puts "  #{c["id"]} [#{c["status"]}] #{c["claim"]}" }
File.write("gate.json", JSON.pretty_generate(gate))

$event = null;
$done  = null;

$ch = curl_init(API . "/run-stream");
curl_setopt_array($ch, [
    CURLOPT_POST       => true,
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer $TOKEN",
        "Content-Type: application/json",
        "Idempotency-Key: pd-001",
    ],
    CURLOPT_POSTFIELDS => json_encode($payload),
    CURLOPT_WRITEFUNCTION => function ($ch, $chunk) use (&$event, &$done) {
        foreach (explode("\n", $chunk) as $line) {
            $line = trim($line);
            if (str_starts_with($line, "event:")) {
                $event = trim(substr($line, 6));
            } elseif (str_starts_with($line, "data:")) {
                $data = json_decode(trim(substr($line, 5)), true);
                if ($event === "delta") { echo "."; }        // live progress
                elseif ($event === "done") { $done = $data; }
                elseif ($event === "error") { throw new Exception($data["message"] ?? "run failed"); }
            }
        }
        return strlen($chunk);
    },
]);
curl_exec($ch);
curl_close($ch);

$gate = json_decode($done["output"]["output"], true);
echo "\n{$done['charged_credits']} credits - {$gate['report_name']} [{$gate['gate']}]\n";
foreach ($gate["claims"] as $c) {
    echo "  {$c['id']} [{$c['status']}] {$c['claim']}\n";
}
file_put_contents("gate.json", json_encode($gate, JSON_PRETTY_PRINT));

var req = new HttpRequestMessage(HttpMethod.Post, Api + "/run-stream") {
    Content = JsonContent.Create(payload),
};
req.Headers.Add("Idempotency-Key", "pd-001");

using var res = await Http.SendAsync(req, HttpCompletionOption.ResponseHeadersRead);
using var reader = new StreamReader(await res.Content.ReadAsStreamAsync());

string? evt = null, done = null;
while (await reader.ReadLineAsync() is { } line)
{
    if (line.StartsWith("event:")) evt = line[6..].Trim();
    else if (line.StartsWith("data:"))
    {
        var data = line[5..].Trim();
        if (evt == "delta") Console.Write(".");            // live progress
        else if (evt == "done") done = data;
        else if (evt == "error") throw new Exception(data);
    }
}

using var final = JsonDocument.Parse(done!);
var text = final.RootElement.GetProperty("output").GetProperty("output").GetString();
using var gateDoc = JsonDocument.Parse(text!);
var gate = gateDoc.RootElement;
Console.WriteLine($"{gate.GetProperty("report_name")} [{gate.GetProperty("gate")}]");
foreach (var c in gate.GetProperty("claims").EnumerateArray())
    Console.WriteLine($"  {c.GetProperty("id")} [{c.GetProperty("status")}] {c.GetProperty("claim")}");
await File.WriteAllTextAsync("gate.json", text!);

#!/usr/bin/env bash
# ci-proof-gate.sh — run after the tests, with their output on disk.
set -euo pipefail

API="https://api.skillsafe.ai/v1/app-api"
TOKEN="${SKILLSAFE_TOKEN:?set SKILLSAFE_TOKEN in the CI secret store}"

# agent-report.md — what the agent (or the PR body) claims
# ci.log        — everything the pipeline actually printed, tail-kept
tail -c 80000 ci.log > evidence.log

jq -n --rawfile claims agent-report.md --rawfile evidence evidence.log \
  --arg stakes "${STAKES:-pr}" \
  '{claims: $claims, evidence: $evidence, stakes: $stakes,
    strictness: "strict",
    context: "CI gate on the merge queue. Evidence is this job'"'"'s own stdout.",
    prescan_facts: {resources: [], flags: []}}' > input.json

# input-derived key: a CI retry of the same commit replays, it does not re-bill
KEY="proof-desk:$(sha256sum input.json | cut -c1-40)"

JOB_ID=$(curl -sf -X POST "$API/run" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -H "Idempotency-Key: $KEY" \
  -d @input.json | jq -r '.data.job_id')

for _ in $(seq 1 120); do
  JOB=$(curl -sf "$API/jobs/$JOB_ID" -H "Authorization: Bearer $TOKEN")
  STATUS=$(echo "$JOB" | jq -r '.data.status')
  case "$STATUS" in succeeded|failed) break ;; esac
  sleep 2
done
[ "$STATUS" = "succeeded" ] || { echo "gate run $STATUS"; exit 2; }

echo "$JOB" | jq -r '.data.output.output' > gate.json

# re-apply the two client-side invariants so the badge matches the ledger
GATE=$(jq -r '
  ([.claims[] | select(.status == "contradicted")] | length) as $contra
  | ([.claims[] | select(.status == "unverified" or .status == "partially-verified")] | length) as $open
  | if $contra > 0 then "blocked"
    elif .gate == "blocked" and $open == 0 then "conditional"
    elif .gate == "pass" and $open > 0 then "conditional"
    else .gate end' gate.json)

jq -r --arg gate "$GATE" '
  "::group::Proof Desk — \(.report_name) [\($gate)]",
  .verdict, "",
  (.claims[] | "  \(.id) [\(.status) · \(.risk) risk] \(.kind) — \(.claim)\n      evidence: \(if .evidence == "" then "none in the log" else .evidence end)\n      \(if .proof_command == "" then "" else "$ " + .proof_command end)"),
  "",
  (.blocking[] | "  BLOCKING: \(.)"),
  (.next_commands[] | "  \(.step). \(.command)"),
  "::endgroup::",
  .summary' gate.json

[ "$GATE" = "blocked" ] && { echo "Gate blocked — the completion claim is not supportable."; exit 1; }
echo "Gate: $GATE"

#!/usr/bin/env python3
"""ci_proof_gate.py — run after the tests, with their output on disk."""
import hashlib, json, pathlib, sys, time

report = pathlib.Path("agent-report.md").read_text(encoding="utf-8")
log = pathlib.Path("ci.log").read_text(encoding="utf-8", errors="replace")[-80_000:]

payload = {
    "claims": report,
    "evidence": log,
    "stakes": "deploy" if BRANCH == "main" else "pr",
    "strictness": "strict",
    "context": "CI gate on the merge queue. Evidence is this job's own stdout.",
    "prescan_facts": {"resources": [], "flags": []},
}

# input-derived key: a CI retry of the same commit replays, it does not re-bill
key = "proof-desk:" + hashlib.sha256(
    json.dumps(payload, sort_keys=True).encode("utf-8")).hexdigest()[:40]

job_id = api("POST", "/run", payload, **{"Idempotency-Key": key})["job_id"]
while True:
    job = api("GET", f"/jobs/{job_id}")
    if job["status"] in ("succeeded", "failed"):
        break
    time.sleep(2)
if job["status"] != "succeeded":
    sys.exit(f"gate run {job['status']}: {job.get('error', '')}")

raw = job["output"]["output"] if isinstance(job["output"], dict) else job["output"]
gate = json.loads(raw)

def settled(g):
    """The two client-side invariants — keep the badge and the ledger in step."""
    contra = any(c["status"] == "contradicted" for c in g["claims"])
    open_ = any(c["status"] in ("unverified", "partially-verified") for c in g["claims"])
    if contra:
        return "blocked"
    if g["gate"] == "blocked" and not open_:
        return "conditional"
    if g["gate"] == "pass" and open_:
        return "conditional"
    return g["gate"]

verdict = settled(gate)
print(f'::group::Proof Desk — {gate["report_name"]} [{verdict}]')
print(gate["verdict"], "\n")
for c in gate["claims"]:
    print(f'  {c["id"]} [{c["status"]} · {c["risk"]} risk] {c["kind"]} — {c["claim"]}')
    print(f'      evidence: {c["evidence"] or "none in the log"}')
    if c["proof_command"]:
        print(f'      $ {c["proof_command"]}   # {c["expected"]}')
for b in gate["blocking"]:
    print("  BLOCKING:", b)
for s in gate["next_commands"]:
    print(f'  {s["step"]}. {s["command"]}')
print("::endgroup::")
print(gate["summary"])

pathlib.Path("gate.json").write_text(json.dumps(gate, indent=2), encoding="utf-8")
sys.exit(1 if verdict == "blocked" else 0)

#!/usr/bin/env node
// ci-proof-gate.mjs — run after the tests, with their output on disk.
import { createHash } from "node:crypto";
import { readFileSync, writeFileSync } from "node:fs";

const report = readFileSync("agent-report.md", "utf8");
const log = readFileSync("ci.log", "utf8").slice(-80_000);

const payload = {
  claims: report,
  evidence: log,
  stakes: branch === "main" ? "deploy" : "pr",
  strictness: "strict",
  context: "CI gate on the merge queue. Evidence is this job's own stdout.",
  prescan_facts: { resources: [], flags: [] },
};

// input-derived key: a CI retry of the same commit replays, it does not re-bill
const key = "proof-desk:" + createHash("sha256")
  .update(JSON.stringify(payload)).digest("hex").slice(0, 40);

const { job_id } = await api("POST", "/run", payload, { "Idempotency-Key": key });

let job;
do {
  await new Promise((r) => setTimeout(r, 2000));
  job = await api("GET", `/jobs/${job_id}`);
} while (job.status !== "succeeded" && job.status !== "failed");
if (job.status !== "succeeded") throw new Error(`gate run ${job.status}`);

const gate = JSON.parse(job.output?.output ?? job.output);

// the two client-side invariants — keep the badge and the ledger in step
const contra = gate.claims.some((c) => c.status === "contradicted");
const open = gate.claims.some((c) =>
  c.status === "unverified" || c.status === "partially-verified");
const verdict = contra ? "blocked"
  : gate.gate === "blocked" && !open ? "conditional"
  : gate.gate === "pass" && open ? "conditional"
  : gate.gate;

console.log(`::group::Proof Desk — ${gate.report_name} [${verdict}]`);
console.log(gate.verdict + "\n");
for (const c of gate.claims) {
  console.log(`  ${c.id} [${c.status} · ${c.risk} risk] ${c.kind} — ${c.claim}`);
  console.log(`      evidence: ${c.evidence || "none in the log"}`);
  if (c.proof_command) console.log(`      $ ${c.proof_command}   # ${c.expected}`);
}
for (const b of gate.blocking) console.log("  BLOCKING:", b);
for (const s of gate.next_commands) console.log(`  ${s.step}. ${s.command}`);
console.log("::endgroup::");
console.log(gate.summary);

writeFileSync("gate.json", JSON.stringify(gate, null, 2));
if (verdict === "blocked") {
  console.error("Gate blocked — the completion claim is not supportable.");
  process.exitCode = 1;
}

// ci-proof-gate.go — run after the tests, with their output on disk.
reportBytes, _ := os.ReadFile("agent-report.md")
logBytes, _ := os.ReadFile("ci.log")
if len(logBytes) > 80000 {
	logBytes = logBytes[len(logBytes)-80000:]
}

payload := map[string]any{
	"claims":        string(reportBytes),
	"evidence":      string(logBytes),
	"stakes":        stakesForBranch(branch), // "deploy" on main, "pr" otherwise
	"strictness":    "strict",
	"context":       "CI gate on the merge queue. Evidence is this job's own stdout.",
	"prescan_facts": map[string]any{"resources": []any{}, "flags": []any{}},
}

// input-derived key: a CI retry of the same commit replays, it does not re-bill
canonical, _ := json.Marshal(payload)
key := "proof-desk:" + fmt.Sprintf("%x", sha256.Sum256(canonical))[:40]

// call() from step 0, with the extra header set on the request:
//   req.Header.Set("Idempotency-Key", key)
var started struct{ JobID string `json:"job_id"` }
if err := callWithKey("POST", "/run", key, payload, &started); err != nil {
	log.Fatal(err)
}

var job struct {
	Status string          `json:"status"`
	Output json.RawMessage `json:"output"`
}
for {
	if err := call("GET", "/jobs/"+started.JobID, nil, &job); err != nil {
		log.Fatal(err)
	}
	if job.Status == "succeeded" || job.Status == "failed" {
		break
	}
	time.Sleep(2 * time.Second)
}
if job.Status != "succeeded" {
	log.Fatalf("gate run %s", job.Status)
}

var wrapper struct{ Output string `json:"output"` }
json.Unmarshal(job.Output, &wrapper)
var gate Gate // the struct from step 4
json.Unmarshal([]byte(wrapper.Output), &gate)

// the two client-side invariants — keep the badge and the ledger in step
contra, open := false, false
for _, c := range gate.Claims {
	if c.Status == "contradicted" {
		contra = true
	}
	if c.Status == "unverified" || c.Status == "partially-verified" {
		open = true
	}
}
verdict := gate.Gate
switch {
case contra:
	verdict = "blocked"
case gate.Gate == "blocked" && !open:
	verdict = "conditional"
case gate.Gate == "pass" && open:
	verdict = "conditional"
}

fmt.Printf("::group::Proof Desk — %s [%s]\n%s\n\n", gate.ReportName, verdict, gate.Verdict)
for _, c := range gate.Claims {
	fmt.Printf("  %s [%s / %s risk] %s — %s\n", c.ID, c.Status, c.Risk, c.Kind, c.Claim)
	if c.ProofCommand != "" {
		fmt.Printf("      $ %s   # %s\n", c.ProofCommand, c.Expected)
	}
}
for _, s := range gate.NextCommands {
	fmt.Printf("  %d. %s\n", s.Step, s.Command)
}
fmt.Println("::endgroup::")
os.WriteFile("gate.json", []byte(wrapper.Output), 0o644)
if verdict == "blocked" {
	os.Exit(1)
}

// CiProofGate.java — run after the tests, with their output on disk.
String report = Files.readString(Path.of("agent-report.md"));
String log = Files.readString(Path.of("ci.log"));
if (log.length() > 80_000) log = log.substring(log.length() - 80_000);

String jsonPayload = """
    {"claims": %s,
     "evidence": %s,
     "stakes": "pr",
     "strictness": "strict",
     "context": "CI gate on the merge queue. Evidence is this job's own stdout.",
     "prescan_facts": {"resources": [], "flags": []}}
    """.formatted(toJsonString(report), toJsonString(log));

// input-derived key: a CI retry of the same commit replays, it does not re-bill
var digest = MessageDigest.getInstance("SHA-256")
    .digest(jsonPayload.getBytes(StandardCharsets.UTF_8));
String key = "proof-desk:" + HexFormat.of().formatHex(digest).substring(0, 40);

// send POST /run with the header Idempotency-Key: key, poll GET /jobs/{id} every
// 2 s, then parse data.output.output as JSON. With the ledger in hand:
//
//   boolean contra = claims.stream().anyMatch(c -> c.status.equals("contradicted"));
//   boolean open   = claims.stream().anyMatch(c -> c.status.equals("unverified")
//                                              || c.status.equals("partially-verified"));
//   String verdict = contra ? "blocked"
//       : gate.equals("blocked") && !open ? "conditional"
//       : gate.equals("pass") && open ? "conditional"
//       : gate;
//
// Print report_name, verdict, every claim with its status, risk, evidence quote and
// proof_command, then blocking[] and next_commands[], and finally:
//
//   if (verdict.equals("blocked")) System.exit(1);

#!/usr/bin/env ruby
# ci_proof_gate.rb — run after the tests, with their output on disk.
require "digest"
require "json"

report = File.read("agent-report.md")
log = File.read("ci.log").slice(-80_000..) || File.read("ci.log")

payload = {
  claims: report,
  evidence: log,
  stakes: branch == "main" ? "deploy" : "pr",
  strictness: "strict",
  context: "CI gate on the merge queue. Evidence is this job's own stdout.",
  prescan_facts: { resources: [], flags: [] }
}

# input-derived key: a CI retry of the same commit replays, it does not re-bill
key = "proof-desk:" + Digest::SHA256.hexdigest(JSON.generate(payload))[0, 40]

started = api_with_key("POST", "/run", payload, key)
job = nil
loop do
  job = api("GET", "/jobs/#{started["job_id"]}")
  break if %w[succeeded failed].include?(job["status"])
  sleep 2
end
abort "gate run #{job["status"]}" unless job["status"] == "succeeded"

gate = JSON.parse(job.dig("output", "output") || job["output"])

# the two client-side invariants — keep the badge and the ledger in step
contra = gate["claims"].any? { |c| c["status"] == "contradicted" }
open   = gate["claims"].any? { |c| %w[unverified partially-verified].include?(c["status"]) }
verdict = if contra then "blocked"
          elsif gate["gate"] == "blocked" && !open then "conditional"
          elsif gate["gate"] == "pass" && open then "conditional"
          else gate["gate"] end

puts "::group::Proof Desk — #{gate["report_name"]} [#{verdict}]"
puts gate["verdict"], ""
gate["claims"].each do |c|
  puts "  #{c["id"]} [#{c["status"]} · #{c["risk"]} risk] #{c["kind"]} — #{c["claim"]}"
  puts "      evidence: #{c["evidence"].empty? ? "none in the log" : c["evidence"]}"
  puts "      $ #{c["proof_command"]}   # #{c["expected"]}" unless c["proof_command"].empty?
end
gate["blocking"].each { |b| puts "  BLOCKING: #{b}" }
gate["next_commands"].each { |s| puts "  #{s["step"]}. #{s["command"]}" }
puts "::endgroup::", gate["summary"]

File.write("gate.json", JSON.pretty_generate(gate))
exit 1 if verdict == "blocked"

#!/usr/bin/env php
<?php
// ci-proof-gate.php — run after the tests, with their output on disk.
$report = file_get_contents("agent-report.md");
$log    = substr(file_get_contents("ci.log"), -80000);

$payload = [
    "claims"        => $report,
    "evidence"      => $log,
    "stakes"        => $branch === "main" ? "deploy" : "pr",
    "strictness"    => "strict",
    "context"       => "CI gate on the merge queue. Evidence is this job's own stdout.",
    "prescan_facts" => ["resources" => [], "flags" => []],
];

// input-derived key: a CI retry of the same commit replays, it does not re-bill
$key = "proof-desk:" . substr(hash("sha256", json_encode($payload)), 0, 40);

$started = apiWithKey("POST", "/run", $payload, $key);
do {
    sleep(2);
    $job = api("GET", "/jobs/" . $started["job_id"]);
} while (!in_array($job["status"], ["succeeded", "failed"]));
if ($job["status"] !== "succeeded") {
    fwrite(STDERR, "gate run {$job['status']}\n");
    exit(2);
}

$gate = json_decode($job["output"]["output"] ?? $job["output"], true);

// the two client-side invariants — keep the badge and the ledger in step
$contra = false; $open = false;
foreach ($gate["claims"] as $c) {
    if ($c["status"] === "contradicted") { $contra = true; }
    if (in_array($c["status"], ["unverified", "partially-verified"])) { $open = true; }
}
$verdict = $contra ? "blocked"
    : ($gate["gate"] === "blocked" && !$open ? "conditional"
    : ($gate["gate"] === "pass" && $open ? "conditional" : $gate["gate"]));

echo "::group::Proof Desk — {$gate['report_name']} [{$verdict}]\n{$gate['verdict']}\n\n";
foreach ($gate["claims"] as $c) {
    echo "  {$c['id']} [{$c['status']} · {$c['risk']} risk] {$c['kind']} — {$c['claim']}\n";
    echo "      evidence: " . ($c["evidence"] ?: "none in the log") . "\n";
    if ($c["proof_command"]) { echo "      $ {$c['proof_command']}   # {$c['expected']}\n"; }
}
foreach ($gate["blocking"] as $b) { echo "  BLOCKING: $b\n"; }
foreach ($gate["next_commands"] as $s) { echo "  {$s['step']}. {$s['command']}\n"; }
echo "::endgroup::\n{$gate['summary']}\n";

file_put_contents("gate.json", json_encode($gate, JSON_PRETTY_PRINT));
exit($verdict === "blocked" ? 1 : 0);

// CiProofGate.cs — run after the tests, with their output on disk.
using System.Security.Cryptography;
using System.Text;

var report = await File.ReadAllTextAsync("agent-report.md");
var log = await File.ReadAllTextAsync("ci.log");
if (log.Length > 80_000) log = log[^80_000..];

var payload = new {
    claims = report,
    evidence = log,
    stakes = branch == "main" ? "deploy" : "pr",
    strictness = "strict",
    context = "CI gate on the merge queue. Evidence is this job's own stdout.",
    prescan_facts = new { resources = Array.Empty<object>(), flags = Array.Empty<object>() },
};

// input-derived key: a CI retry of the same commit replays, it does not re-bill
var canonical = JsonSerializer.Serialize(payload);
var key = "proof-desk:" + Convert.ToHexString(
    SHA256.HashData(Encoding.UTF8.GetBytes(canonical)))[..40].ToLowerInvariant();

var started = await SkillSafe.ApiAsync(HttpMethod.Post, "/run", payload, key);
JsonElement job;
while (true)
{
    job = await SkillSafe.ApiAsync(HttpMethod.Get,
        $"/jobs/{started.GetProperty("job_id").GetString()}");
    var status = job.GetProperty("status").GetString();
    if (status is "succeeded" or "failed") break;
    await Task.Delay(2000);
}
if (job.GetProperty("status").GetString() != "succeeded") return 2;

var rawText = job.GetProperty("output").GetProperty("output").GetString()!;
using var doc = JsonDocument.Parse(rawText);
var gate = doc.RootElement;
var claims = gate.GetProperty("claims").EnumerateArray().ToList();

// the two client-side invariants — keep the badge and the ledger in step
bool contra = claims.Any(c => c.GetProperty("status").GetString() == "contradicted");
bool open = claims.Any(c => c.GetProperty("status").GetString() is "unverified" or "partially-verified");
var declared = gate.GetProperty("gate").GetString();
var verdict = contra ? "blocked"
    : declared == "blocked" && !open ? "conditional"
    : declared == "pass" && open ? "conditional"
    : declared;

Console.WriteLine($"::group::Proof Desk — {gate.GetProperty("report_name")} [{verdict}]");
Console.WriteLine(gate.GetProperty("verdict") + "\n");
foreach (var c in claims)
{
    Console.WriteLine($"  {c.GetProperty("id")} [{c.GetProperty("status")} / " +
                      $"{c.GetProperty("risk")} risk] {c.GetProperty("kind")} — {c.GetProperty("claim")}");
    Console.WriteLine($"      evidence: {c.GetProperty("evidence")}");
}
foreach (var s in gate.GetProperty("next_commands").EnumerateArray())
    Console.WriteLine($"  {s.GetProperty("step")}. {s.GetProperty("command")}");
Console.WriteLine("::endgroup::");

await File.WriteAllTextAsync("gate.json", rawText);
return verdict == "blocked" ? 1 : 0;