Drive GoConc Desk from your own code

The page reads pasted Go in the browser for free — one or more files joined into one paste, each introduced by a // file: <path> line, plus go.mod for the Go version — with its line numbers. It lexes strings, runes and comments out first, matches every brace, inventories every function, goroutine (go statements and errgroup Go), loop, select, channel, Lock/Unlock pair, WaitGroup, derived context and HTTP handler, and runs 23 deterministic checks drawn from Go concurrency practice (catalogue ids GC-01..GC-23, plus GC-24 for context): loop variables captured by goroutines before Go 1.22, wg.Add inside the goroutine it counts, WaitGroups that never balance, locks and WaitGroups copied by value, a Lock with no Unlock on every path, RLock released with Unlock, maps and counters written from goroutines with no lock, atomic and plain access mixed, goroutines blocked forever on an abandoned unbuffered channel, a range over a channel nothing closes, a close from goroutines started in a loop, goroutine loops that cannot be stopped, busy-spinning selects, discarded cancel funcs, context.Background() where a context is in scope, goroutines that outlive their request, goroutine errors nobody sees, unbounded fan-out, time.After in a loop, tickers never stopped, time.Sleep as synchronisation and a context stored in a struct. Nothing is compiled or run, and it is not the race detector: every flag is a reading of the text. Its two paid steps are available over HTTP. You send one JSON object with task set to "audit" or "fix", the paste as code and the page’s check as a facts string, and the model replies with one JSON object: an audit that rates the four areas, answers every flag and gives exact before/after edits per finding, or the whole fixed file(s) with a list of every change tied to the page’s flags.

Base URL: https://api.skillsafe.ai/v1/app-api. Every call sends Content-Type: application/json and, once you have a token, Authorization: Bearer <token>. The paths below (/guest, /me, /estimate, /run, /jobs/{job_id}, /run-stream) are relative to it, exactly as sdk.js calls them. A plain-text summary of the app for agents is at /llms.txt. Both lanes run on the gpt-terra model with a 10% publisher markup. A run needs a signed-in (user) token and is metered: the platform places a hold on your credits when the run starts and then charges only what the run used. /estimate is free.

The response envelope

Responses are JSON of the form {"ok": ..., "data": ..., "error": {...}}. The page’s SDK (sdk.js) decides success from the HTTP status, not from ok: on a 2xx it returns data; otherwise it raises an error whose message is error.message (or the HTTP status text when the body carries none), with status, code (error.code) and details (error.details) attached. A body that is not JSON is treated as {}.

{ "ok": true,  "data": { ... } }
{ "ok": false, "error": { "code": "...", "message": "...", "details": { ... } } }

Error codes

Branch on the HTTP status and error.code, show error.message. The page handles 401 and 402 by name; the rest reach it as a generic failure (“The run failed: ...”).

Failures that do not arrive as an HTTP status:

The task field: two lanes

task routes the run, and it takes exactly two values: "audit" and "fix". Each lane has its own reply contract, and a reply never mixes them. The skill’s instructions tell the model to do the audit lane when task is missing or anything else (and the page’s own Gokit.buildInput turns any lane that is not "fix" into "audit"), so a typo silently gets you an audit: always send one of the two values.

The page chains the two: after an audit, “Apply every edit and fix the rest” puts every audit edit into the paste, switches to the fix lane on that edited paste and adds an audit_handoff string (below) with the audit’s verdict, headline and findings. Over the API that is a second run with task: "fix", the edited paste as code, facts recomputed from the edited paste, and that string. The page drops the handoff as soon as the paste is edited again.

Guards the page applies before a run and the API does not: it refuses to price or run a paste it cannot read as Go (“Nothing was pasted.”, “No Go file was found. Paste .go source, with a // file: <path>.go line above each file.”, or “This does not read as Go source: no package clause, import or func was found.”), and it warns before a run on a paste with no concurrency (“No goroutine, channel or lock was found: there may be little concurrency here to audit.”, or “... to fix.”) or with no function (“No func was found; the run will see package-level code only.”).

Input fields

This is exactly what the page sends (gokit.js buildInput(lane, A, note, handoff), checked by mustBeObject; app.js currentInput and run), and what input-schema.json declares. The platform’s input schema is scalar-only, so every value is a string. buildInput emits them in the order task, code, facts, note, audit_handoff:

mustBeObject only insists on a plain object that is not wrapped in {"input": ...}; it is buildInput that leaves a blank note out, which is why an empty note is simply absent.

The code string

code is the paste itself. A line // file: <path> (a path with a . or / in it) starts each file, and a --- line just before it only separates files. Files dropped on the page (or a dropped package folder) are joined that way by Gokit.joinFiles: each file under its // file: line, trailing whitespace removed, joined by newlines, ending in a newline. A paste with no // file: line is read as one file, main.go (or go.mod when it holds a module line and no package clause). The page normalises line endings to \n. A .go path is checked as Go; go.mod is read for its go line (loop variable semantics changed in Go 1.22); go.sum and go.work are deps; anything else is other. Go indents with tabs and the paste keeps them. Send the text you want the reply to quote: every file in an audit reply must be a path from facts.files, every line must fall inside that file, every evidence must be copied from it, and every edit’s before must occur in it exactly once.

The page reads up to 400 000 characters (MAX_TEXT, cut at a line) and 40 files (MAX_FILES), and sends at most 60 000 characters (MAX_SEND): past that buildInput drops whole files from the end — the last non-Go file first, then the last file — until the rest fits, cuts a single remaining file at a line (“the end of <path>”) if it still does not, and ends the string with one line naming what it left out:

// [goconc-desk: not sent: pkg/b.go, pkg/c.go]

The model is told never to quote or rewrite what was not sent, and facts.notes gets the sentence “Not sent (the paste is over 60,000 characters): ... The page checked them; the run did not see them.” facts is still computed from the whole paste. The worked examples below are small, so their code is the paste unchanged.

The facts string

facts is optional to compute but required to send. It is produced by the page’s free check: Gokit.analyze splits the paste into files, lexes and inventories them and runs the rules, and Gokit.facts(A) turns that analysis into the object below (it does not depend on the lane: an audit and a fix run of the same paste carry the same facts). It is how the model knows which flags to answer, which file paths and line ranges to name, and which functions must survive. Its top-level keys, in the order built:

The simplest source is gokit.js itself: the page loads it from /gokit.js, and it also runs in Node (it sets module.exports). This script prints what the page would send as code and facts (with the 60 000-character cut applied), with the facts decoded so you can read them; the step 4 samples compact them back into the page’s string byte for byte. Save the paste as crawler-paste.txt and redirect the output into crawler-check.json:

// build-check.js -- run: node build-check.js crawler-paste.txt > crawler-check.json   (gokit.js saved next to it)
const fs = require("fs");
const Gokit = require("./gokit.js");
const A = Gokit.analyze(fs.readFileSync(process.argv[2], "utf8"));
if (!A.ok) { console.error(A.errors.join("\n")); process.exit(1); }
const inp = Gokit.buildInput("audit", A, "", null);          // code and facts do not depend on the lane
console.log(JSON.stringify({ code: inp.code, facts: JSON.parse(inp.facts) }, null, 2));
const real = A.flags.filter((f) => f.sev !== "info");
console.error(A.files.length + " file(s), " + A.goroutines.length + " goroutine(s), " + A.handlers.length + " handler(s); " +
  real.length + " flags (" + A.counts.high + " high, " + A.counts.medium + " medium, " + A.counts.low + " low); verdict_candidate " + A.candidate);

For the crawler example it reports 2 file(s), 1 goroutine(s), 0 handler(s); 7 flags (6 high, 0 medium, 1 low); verdict_candidate blocked; for the pipeline example, 2 file(s), 3 goroutine(s), 0 handler(s); 4 flags (3 high, 1 medium, 0 low); verdict_candidate blocked. For both worked examples its code and facts are exactly what the page sends.

Without the page’s check. The platform only checks that facts is a string, so a minimal object works — "{}", or a hand-built one such as {"flags": [], "notes": ["No page check was run; read the code directly."]} — and the model still reads code. But you lose what the check adds: with no flags there is nothing to confirm, dismiss or close, with no files there are no paths and line ranges to name, and with no functions nothing says what must survive a fix. Build it with gokit.js as above when you can.

The audit_handoff string

Only for task: "fix", and only for the code the audit was about with every audit edit applied. The page builds both from the normalised audit reply res (recon.js normalize, below) and the analysis A of the audited paste, in recon.js fixHandoff:

const run = Recon.applyFindings(A, res.findings, Gokit);   // every finding's edits, in order, each on top of the last
JSON.stringify({ verdict: res.verdict, headline: res.headline,
  findings: res.findings.map(f => ({ id: f.id, severity: f.severity, file: f.file, line: f.line, title: f.title, why: f.why, edits: f.edits.length })),
  applied: /* edits that applied */, failed: /* edits that did not */ })
// run.A.text is the edited paste: it becomes code, and facts is recomputed from it

That is {"verdict", "headline", "findings": [{id, severity, file, line, title, why, edits}], "applied", "failed"}, where each finding’s edits is the number of edits it carried. applyFindings applies every finding’s edits with Gokit.applyEdits, in the order listed: each before must occur exactly once in its file as the earlier edits left it (leading and trailing blank lines ignored; an edit whose indentation differs from the file only in tabs versus spaces is matched line by line and re-indented to the file’s own tabs), or that edit is reported as failed and skipped. The handoff is a previous reply, not evidence: the model checks it against code and fixes what is left. This script does the whole step — the edited paste, its recomputed facts and the handoff string, in the same shape as build-check.js prints, so the samples read it the same way:

// handoff.js -- run: node handoff.js crawler-paste.txt crawler-reply.txt > crawler-fix-check.json   (gokit.js, recon.js next to it)
const fs = require("fs");
const Gokit = require("./gokit.js");
const Recon = require("./recon.js");
const A = Gokit.analyze(fs.readFileSync(process.argv[2], "utf8"));             // the audited paste
const res = Recon.normalize(Recon.parseResult(fs.readFileSync(process.argv[3], "utf8")), "audit");
const ho = Recon.fixHandoff(A, res);                                            // every edit, in order
const B = Gokit.analyze(ho.text);                                               // facts recomputed from the edited paste
const inp = Gokit.buildInput("fix", B, "", ho.handoff);
console.log(JSON.stringify({ code: inp.code, facts: JSON.parse(inp.facts), audit_handoff: inp.audit_handoff }, null, 2));
console.error(ho.applied + " edit(s) applied, " + ho.failed + " did not apply");

Save the audit’s output.output as crawler-reply.txt; for the crawler example it reports 5 edit(s) applied, 0 did not apply. The third worked example below is exactly that run.

The output contracts

The model is instructed (SKILL.md) to reply with one JSON object and nothing else — no prose, no code fences — with every array of its lane present ([] when empty). The run’s output text is that object. In both lanes it must ground everything in code: a function, type, caller, test, close, Unlock or Wait that is not in the paste is never claimed to exist — it goes into questions. It must never write a secret value: a line that holds a literal credential is never copied into the reply (not in evidence, not in an edit, not in a file), and no credential, real hostname or endpoint is invented. It must never change what the code does for its callers: same exported functions, names, parameters, results and values on the paths that worked, unless the note asks for it. Every page flag whose sev is not info is answered exactly once (audit lane: in flag_answers), and an info flag is never reported as a finding.

task: "audit"

• task: "audit".
• verdict: blocked (any finding is high) | needs_work (the worst is medium) | ready (nothing above low; low findings and questions do not stop a release).
• headline: one sentence. component: one or two sentences — what the code does and what runs concurrently in it.
• areas[]: exactly four entries, in the order lifecycle, shared_state, channels, cancellation: {area, status, note} with status sound | fragile | broken (broken when a high finding sits in that area, fragile for a medium one).
• findings[]: {id, flags[], file, line, severity, area, title, evidence, why, edits[]}. id is a catalogue id (GC-01..GC-23) or other; flags lists the page uids it confirms ([] for something the page did not flag); file is a path from facts.files, copied exactly; line is the line of code with the offending text, inside that file’s line..end_line; severity is high (a data race, a deadlock or panic, a goroutine that leaks on every call, a discarded cancel func) | medium (goroutines that cannot be stopped, a spinning select, dropped cancellation, a request used after its handler returned, an error nobody sees) | low (bounded risk or hygiene); area is lifecycle | shared_state | channels | cancellation; evidence is one to three whole lines copied verbatim from code as pasted.
• edits[]: {before, after} on that one file. Each before is a contiguous, exact slice of the file — whole lines with their tabs, as pasted — that occurs exactly once in the file as it stands when the edit is applied; after is its replacement. Findings are applied in the order listed and their edits in order, each on top of the ones before, so a later finding that touches the same lines writes its before as the earlier one left it. edits may be [] only for a low finding or a change outside the paste.
• flag_answers[]: {flag, status, reason}, exactly one per non-info page flag, status confirmed (a finding lists that uid) | dismissed (with the reason).
• plan[]: the findings in the order to apply them, ending with go vet ./... and go test -race ./.... questions[] (only what the paste cannot answer) and summary (two to four sentences, answering note if one was sent).

task: "fix"

• task: "fix".
• verdict: fixed (open is empty) | partial.
• headline: one sentence.
• files[]: {path, content} — every pasted Go file it changes, whole (every line, without the // file: line, indented with tabs as gofmt writes it), under its path from facts.files; at most one new file next to them. Only the standard library and packages the paste already shows; golang.org/x/sync/errgroup only when it is already imported or go.mod requires golang.org/x/sync.
• changes[]: {file, function, flags[], change, why}, one per change. function is the function or method it is in, as facts.functions names it (Type.Method), or (package); flags are the page flags the change closes. Every high and medium flag appears in the flags of a change or of an open item.
• verify[]: always go vet ./... and go test -race ./..., plus the test that would have caught the worst problem.
• open[]: {item, flags[], reason} for what it left unfixed. questions[] and summary, as in the audit lane; with an audit_handoff, it fixes what the audit left.

How the page reads a reply (recon.js parseResult and normalize): it strips a code fence and parses from the first { to the last }. A reply is read as the lane that was asked for, unless it names the other lane and carries that lane’s body (a files array for fix, a findings array for audit). An unknown verdict shows as needs_work or partial and counts as a disagreement; an unknown severity becomes medium; ids like GC7 or gc 7 become GC-07; flags keeps only F<n> values; findings with no file, evidence and title are dropped; file may also arrive as path, a change’s function as func and its change as what, and an open item as path; questions is capped at 10, plan at 30 and verify at 20. An audit reply carries 9 sections (verdict, headline, component, areas, findings, flag_answers, plan, questions, summary) and a fix reply 8 (verdict, headline, files, changes, verify, open, questions, summary), which is what the page counts when it recovers a partial reply.

Worked examples

All three are examples the page ships (the example buttons on the app page; the full pastes are in /example.js, ids crawler and pipeline), built exactly as the page builds them: Gokit.buildInput(lane, Gokit.analyze(text), note, handoff), with the real model reply the page replays for each (example-result.js, keys crawler, pipeline and crawler:fix). The pastes are shown whole; the request bodies cut the long code, facts and audit_handoff strings with a visible ..., and the replies are pretty-printed for display. Every value shown is copied from the input or the reply. Neither paste holds a credential.

Audit: a link checker that races on one map and copies its mutex

Two files, go.mod (go 1.21) and crawler/crawler.go: a link checker for the Kestrelmoor docs site. CheckAll starts one goroutine per URL, calls wg.Add(1) inside it, reads the loop variable u, and writes a results map and a failures counter from every goroutine with no lock; check throws away the cancel func of its context.WithTimeout, and Checked has a value receiver on a struct that holds a sync.Mutex. The page’s free check raises 7 flags (6 high, 1 low) (plus the GC-24 context flag); its own reading of the verdict is blocked. The engineer’s note: “The link checker sometimes crashes with 'concurrent map writes' and the failure count is always wrong. What do we fix before it runs on the whole docs site?”

The code string, whole: 1,581 characters, 77 lines ending in a newline. Save it as crawler-paste.txt and run node build-check.js crawler-paste.txt > crawler-check.json:

// file: go.mod
module example.com/linkcheck

go 1.21
// file: crawler/crawler.go
package crawler

import (
	"context"
	"fmt"
	"net/http"
	"sync"
	"time"
)

// Result is what one URL check found.
type Result struct {
	URL    string
	Status int
	Err    error
}

// Checker checks the links of the Kestrelmoor docs site.
type Checker struct {
	client  *http.Client
	mu      sync.Mutex
	checked int
}

func NewChecker() *Checker {
	return &Checker{client: &http.Client{Timeout: 10 * time.Second}}
}

// CheckAll fetches every URL at once and returns the result of each.
func (c *Checker) CheckAll(ctx context.Context, urls []string) map[string]Result {
	results := make(map[string]Result)
	var wg sync.WaitGroup
	failures := 0
	for _, u := range urls {
		go func() {
			wg.Add(1)
			defer wg.Done()
			res := c.check(ctx, u)
			results[u] = res
			if res.Err != nil {
				failures++
			}
		}()
	}
	wg.Wait()
	fmt.Printf("checked %d urls, %d failures\n", len(urls), failures)
	return results
}

func (c *Checker) check(ctx context.Context, url string) Result {
	ctx, _ = context.WithTimeout(ctx, 5*time.Second)
	req, err := http.NewRequestWithContext(ctx, http.MethodHead, url, nil)
	if err != nil {
		return Result{URL: url, Err: err}
	}
	resp, err := c.client.Do(req)
	if err != nil {
		return Result{URL: url, Err: err}
	}
	resp.Body.Close()
	c.mu.Lock()
	c.checked++
	c.mu.Unlock()
	return Result{URL: url, Status: resp.StatusCode}
}

// Checked reports how many URLs have been checked so far.
func (c Checker) Checked() int {
	c.mu.Lock()
	defer c.mu.Unlock()
	return c.checked
}

Its facts, decoded (the request carries this object as one compact JSON string):

{
  "component": {
    "go_version": "1.21",
    "go_files": 1,
    "primitives": [
      "sync",
      "context",
      "time"
    ],
    "goroutines": 1,
    "handlers": 0
  },
  "files": [
    {
      "path": "go.mod",
      "kind": "gomod",
      "line": 2,
      "end_line": 4
    },
    {
      "path": "crawler/crawler.go",
      "kind": "go",
      "line": 6,
      "end_line": 78
    }
  ],
  "functions": [
    {
      "name": "NewChecker",
      "file": "crawler/crawler.go",
      "line": 30
    },
    {
      "name": "Checker.CheckAll",
      "file": "crawler/crawler.go",
      "line": 35
    },
    {
      "name": "Checker.check",
      "file": "crawler/crawler.go",
      "line": 55
    },
    {
      "name": "Checker.Checked",
      "file": "crawler/crawler.go",
      "line": 73
    }
  ],
  "handlers": [],
  "goroutines": [
    {
      "file": "crawler/crawler.go",
      "line": 40,
      "func": "Checker.CheckAll",
      "kind": "literal",
      "target": null,
      "in_loop": true
    }
  ],
  "channels": [],
  "locks": [
    {
      "target": "c.mu",
      "kind": "Lock",
      "file": "crawler/crawler.go",
      "line": 66,
      "func": "Checker.check",
      "unlock": "explicit"
    },
    {
      "target": "c.mu",
      "kind": "Lock",
      "file": "crawler/crawler.go",
      "line": 74,
      "func": "Checker.Checked",
      "unlock": "deferred"
    }
  ],
  "waitgroups": [
    {
      "name": "wg",
      "file": "crawler/crawler.go",
      "line": 37
    }
  ],
  "contexts": [
    {
      "file": "crawler/crawler.go",
      "line": 56,
      "func": "Checker.check",
      "kind": "WithTimeout",
      "cancel": "discarded"
    }
  ],
  "flags": [
    {
      "uid": "F1",
      "id": "GC-02",
      "sev": "high",
      "file": "crawler/crawler.go",
      "line": 41,
      "text": "wg.Add runs inside the goroutine it counts",
      "detail": "Wait can run before the goroutine is scheduled, see a zero counter and return while work is still going on. Call Add before the go statement."
    },
    {
      "uid": "F2",
      "id": "GC-01",
      "sev": "high",
      "file": "crawler/crawler.go",
      "line": 43,
      "text": "the goroutine reads the loop variable u from the enclosing for",
      "detail": "go.mod says go 1.21: before Go 1.22 every iteration shares one u, so the goroutines see whatever value it has when they run - usually the last. Pass it as an argument (go func(u T) {...}(u)) or copy it (u := u) inside the loop."
    },
    {
      "uid": "F3",
      "id": "GC-07",
      "sev": "high",
      "file": "crawler/crawler.go",
      "line": 44,
      "text": "map results is written from goroutines started in a loop with no lock",
      "detail": "Two goroutines writing a Go map at once is a fatal runtime error (concurrent map writes), not just a wrong value. Guard it with a sync.Mutex held around every read and write, give each goroutine its own result and merge after Wait, or send results over a channel."
    },
    {
      "uid": "F4",
      "id": "GC-08",
      "sev": "high",
      "file": "crawler/crawler.go",
      "line": 46,
      "text": "failures++ runs from goroutines started in a loop with no lock or atomic",
      "detail": "Read-modify-write on a shared variable from several goroutines is a data race: updates are lost and go test -race reports it. Use sync/atomic (atomic.Int64 and .Add), hold a mutex, or count per goroutine and sum after Wait."
    },
    {
      "uid": "F5",
      "id": "GC-15",
      "sev": "high",
      "file": "crawler/crawler.go",
      "line": 56,
      "text": "the cancel func of context.WithTimeout is thrown away",
      "detail": "The context and its timer stay alive until the parent is cancelled (go vet lostcancel): under load that is a leak per call, and nothing can stop the work early. Keep it: ctx, cancel := ... and defer cancel()."
    },
    {
      "uid": "F6",
      "id": "GC-04",
      "sev": "high",
      "file": "crawler/crawler.go",
      "line": 73,
      "text": "Checker.Checked has a value receiver, so it copies Checker's sync.Mutex",
      "detail": "The method locks its own copy of the mutex, so two callers never exclude each other and the struct's state races (go vet copylocks). Use a pointer receiver: func (c *Checker)."
    },
    {
      "uid": "F7",
      "id": "GC-19",
      "sev": "low",
      "file": "crawler/crawler.go",
      "line": 40,
      "text": "one goroutine per item of urls, with no limit",
      "detail": "Fan-out grows with the input: 10,000 items start 10,000 goroutines, each holding a connection or a file. Bound it - errgroup's SetLimit(n), a buffered semaphore channel, or a fixed pool of workers reading a jobs channel."
    },
    {
      "uid": "F8",
      "id": "GC-24",
      "sev": "info",
      "file": "crawler/crawler.go",
      "line": 6,
      "text": "context: 1 goroutine(s), 0 channel(s), 2 lock call(s), 1 derived context(s); go.mod says go 1.21",
      "detail": "Also read: go.mod (gomod). Only what is pasted is checked: a Close, Unlock or Wait that happens in a file you did not paste is outside the check. The page does not run the race detector - go test -race is the ground truth."
    }
  ],
  "verdict_candidate": "blocked",
  "notes": []
}

The request body (POST /estimate, then POST /run or /run-stream with Idempotency-Key: goconc-desk:audit:fb06d86d-1942:a1 as the page sends it):

{
  "task": "audit",
  "code": "// file: go.mod\nmodule example.com/linkcheck\n\ngo 1.21\n// file: crawler/crawler.go\npackage crawler\n\nimport (\n\t\"context\"\n\t\"fmt\"\n\t\"net/http\"\n\t\"sync\"\n\t\"time\"\n)\n\n// Result is ...",
  "facts": "{\"component\":{\"go_version\":\"1.21\",\"go_files\":1,\"primitives\":[\"sync\",\"context\",\"time\"],\"goroutines\":1,\"handlers\":0},\"files\":[{\"path\":\"go.mod\",\"kind\":\"g...",
  "note": "The link checker sometimes crashes with 'concurrent map writes' and the failure count is always wrong. What do we fix before it runs on the whole docs site?"
}

The reply (output.output), whole:

{
  "task": "audit",
  "verdict": "blocked",
  "headline": "CheckAll spawns unsynchronized goroutines that race on a shared map and counter and can return before they finish, which is the concurrent-map-write crash and the wrong failure count you're seeing.",
  "component": "Checker.CheckAll fans out one goroutine per URL to HEAD-check a Kestrelmoor docs link list concurrently, collecting each Result into a shared map and a failure count before returning; check derives a 5s per-call timeout from the caller's context and updates a shared counter under a mutex.",
  "areas": [
    {
      "area": "lifecycle",
      "status": "broken",
      "note": "wg.Add(1) runs inside the goroutine it counts and the loop variable u is captured by reference on Go 1.21, so goroutines are miscounted and can check the wrong URL or let Wait return before all checks finish."
    },
    {
      "area": "shared_state",
      "status": "broken",
      "note": "The results map and failures counter are written from every goroutine with no lock, and Checked's value receiver copies the mutex meant to guard checked."
    },
    {
      "area": "channels",
      "status": "sound",
      "note": "No channels are used anywhere in this component, so there is nothing to close, range over or select on."
    },
    {
      "area": "cancellation",
      "status": "broken",
      "note": "check discards the cancel func returned by context.WithTimeout, leaking a timer on every call."
    }
  ],
  "findings": [
    {
      "id": "GC-02",
      "flags": [
        "F1",
        "F2"
      ],
      "file": "crawler/crawler.go",
      "line": 41,
      "severity": "high",
      "area": "lifecycle",
      "title": "wg.Add runs inside the goroutine, and it closes over the shared loop variable u",
      "evidence": "for _, u := range urls {\n\tgo func() {\n\t\twg.Add(1)",
      "why": "wg.Add(1) runs inside the goroutine, so wg.Wait() on line 50 can see a zero counter before any goroutine has registered and return while checks are still in flight -- the caller then holds a results map and failures count that leftover goroutines are still writing after CheckAll has returned. Because the goroutine reads the loop variable u directly (not a parameter or a copy) and go.mod pins Go 1.21, every goroutine can also see whatever value u has when it runs instead of the URL it was launched for, so some URLs are checked under the wrong key and others never get checked.",
      "edits": [
        {
          "before": "\tfor _, u := range urls {\n\t\tgo func() {\n\t\t\twg.Add(1)\n\t\t\tdefer wg.Done()\n\t\t\tres := c.check(ctx, u)\n\t\t\tresults[u] = res\n\t\t\tif res.Err != nil {\n\t\t\t\tfailures++\n\t\t\t}\n\t\t}()\n\t}",
          "after": "\tfor _, u := range urls {\n\t\twg.Add(1)\n\t\tgo func(u string) {\n\t\t\tdefer wg.Done()\n\t\t\tres := c.check(ctx, u)\n\t\t\tresults[u] = res\n\t\t\tif res.Err != nil {\n\t\t\t\tfailures++\n\t\t\t}\n\t\t}(u)\n\t}"
        }
      ]
    },
    {
      "id": "GC-07",
      "flags": [
        "F3",
        "F4"
      ],
      "file": "crawler/crawler.go",
      "line": 44,
      "severity": "high",
      "area": "shared_state",
      "title": "the results map and the failures counter are written from every goroutine with no lock",
      "evidence": "results[u] = res\nif res.Err != nil {\n\tfailures++",
      "why": "results[u] = res runs in every one of the per-URL goroutines with no lock: two goroutines writing the same Go map at once is a fatal 'concurrent map writes' runtime error, not just a wrong value, which matches the crash you're seeing. failures++ is a read-modify-write on a shared variable from several goroutines -- a data race that go test -race reports -- so increments are silently lost under load, which is why the printed failure count is always wrong.",
      "edits": [
        {
          "before": "\tvar wg sync.WaitGroup",
          "after": "\tvar mu sync.Mutex\n\tvar wg sync.WaitGroup"
        },
        {
          "before": "\tfor _, u := range urls {\n\t\twg.Add(1)\n\t\tgo func(u string) {\n\t\t\tdefer wg.Done()\n\t\t\tres := c.check(ctx, u)\n\t\t\tresults[u] = res\n\t\t\tif res.Err != nil {\n\t\t\t\tfailures++\n\t\t\t}\n\t\t}(u)\n\t}",
          "after": "\tfor _, u := range urls {\n\t\twg.Add(1)\n\t\tgo func(u string) {\n\t\t\tdefer wg.Done()\n\t\t\tres := c.check(ctx, u)\n\t\t\tmu.Lock()\n\t\t\tresults[u] = res\n\t\t\tif res.Err != nil {\n\t\t\t\tfailures++\n\t\t\t}\n\t\t\tmu.Unlock()\n\t\t}(u)\n\t}"
        }
      ]
    },
    {
      "id": "GC-04",
      "flags": [
        "F6"
      ],
      "file": "crawler/crawler.go",
      "line": 73,
      "severity": "high",
      "area": "shared_state",
      "title": "Checker.Checked has a value receiver and copies the mutex it locks",
      "evidence": "func (c Checker) Checked() int {",
      "why": "Checked has a value receiver, so c -- including its sync.Mutex -- is copied on every call. Lock/Unlock inside Checked then operate on that copy, not the Checker instance's mutex, so a call to Checked() no longer excludes a concurrent write to checked in check(): go vet's copylocks check flags this, and Checked() can read checked while another goroutine is mid-increment on the real struct.",
      "edits": [
        {
          "before": "func (c Checker) Checked() int {",
          "after": "func (c *Checker) Checked() int {"
        }
      ]
    },
    {
      "id": "GC-15",
      "flags": [
        "F5"
      ],
      "file": "crawler/crawler.go",
      "line": 56,
      "severity": "high",
      "area": "cancellation",
      "title": "the cancel func of context.WithTimeout is discarded",
      "evidence": "ctx, _ = context.WithTimeout(ctx, 5*time.Second)",
      "why": "The context and its timer stay referenced until the parent ctx is done (go vet's lostcancel check flags this): with one call per URL and no cancel, this leaks one timer per check() call for as long as the crawl runs, and nothing can free it early once the request completes.",
      "edits": [
        {
          "before": "\tctx, _ = context.WithTimeout(ctx, 5*time.Second)",
          "after": "\tctx, cancel := context.WithTimeout(ctx, 5*time.Second)\n\tdefer cancel()"
        }
      ]
    },
    {
      "id": "GC-19",
      "flags": [
        "F7"
      ],
      "file": "crawler/crawler.go",
      "line": 40,
      "severity": "low",
      "area": "lifecycle",
      "title": "one goroutine per URL with no limit",
      "evidence": "for _, u := range urls {\n\tgo func() {",
      "why": "CheckAll starts one goroutine per URL with no bound: fine for a short list, but pointed at the whole docs site it opens as many outbound HTTP connections at once as there are URLs, which can exhaust file descriptors or trip the target site's rate limiting. Bound it with errgroup's SetLimit(n) or a fixed-size worker pool reading a jobs channel before running this at scale; the fix is outside these findings' edits since it changes CheckAll's structure rather than one line.",
      "edits": []
    }
  ],
  "flag_answers": [
    {
      "flag": "F1",
      "status": "confirmed",
      "reason": "wg.Add(1) is called from inside the goroutine it counts, so Wait can race ahead of it."
    },
    {
      "flag": "F2",
      "status": "confirmed",
      "reason": "the goroutine reads the loop variable u directly and go.mod pins Go 1.21, which shares one u across iterations."
    },
    {
      "flag": "F3",
      "status": "confirmed",
      "reason": "results[u] = res writes the shared map from every goroutine with no lock."
    },
    {
      "flag": "F4",
      "status": "confirmed",
      "reason": "failures++ is an unsynchronized read-modify-write from every goroutine."
    },
    {
      "flag": "F5",
      "status": "confirmed",
      "reason": "the cancel func returned by context.WithTimeout is assigned to _ and never called."
    },
    {
      "flag": "F6",
      "status": "confirmed",
      "reason": "Checked has a value receiver, so it locks a copy of Checker's mutex instead of the real one."
    },
    {
      "flag": "F7",
      "status": "confirmed",
      "reason": "CheckAll starts one goroutine per entry of urls with no limit on how many run at once."
    }
  ],
  "plan": [
    "In CheckAll, call wg.Add(1) before each go statement and pass u into the goroutine as a parameter (go func(u string) {...}(u)), so every goroutine is counted before it can finish and checks the URL it was launched for (GC-02, GC-01).",
    "Add a sync.Mutex in CheckAll and hold it around both results[u] = res and failures++ inside the goroutine, so the map write and the counter are serialized and the concurrent-map-write panic and the wrong failure count both go away (GC-07, GC-08).",
    "Change Checker.Checked to a pointer receiver (func (c *Checker) Checked() int) so its Lock/Unlock act on the real mutex instead of a copy (GC-04).",
    "In check, keep the cancel func from context.WithTimeout and defer cancel() (GC-15).",
    "Bound the number of concurrent checks (errgroup.SetLimit or a fixed worker pool) before pointing CheckAll at the whole docs site (GC-19).",
    "Run go vet ./... and go test -race ./... with a test that calls CheckAll concurrently against a local httptest.Server and asserts both no race and a correct failures count."
  ],
  "questions": [
    "Can go.mod's go line move to 1.22 or later? That makes each loop iteration's u its own variable by default, so the explicit func(u string) parameter becomes a belt-and-suspenders fix rather than a required one.",
    "Do any callers of CheckAll read the returned map or rely on Checked() while a previous CheckAll call might still be running in the background, or is CheckAll always awaited fully before the next call?"
  ],
  "summary": "The crash and the wrong count share one root cause: wg.Add(1) runs inside the goroutine it counts, and the results map and failures counter it starts are written from every goroutine with no lock, so Wait can return early and the map write races -- that is the 'concurrent map writes' panic -- while failures++ silently loses increments. Fix the launch (Add before go, pass u as a parameter) and guard results[u]=res and failures++ with one mutex; Checked's value receiver (it copies the guarding mutex) and check's discarded cancel func are separate high-severity bugs worth fixing in the same pass. Before running this against the whole docs site, also bound how many goroutines run at once -- right now it's one per URL with no limit."
}

Two findings each carry two flags (one change closes both), every one of the 7 flags is confirmed, and the low GC-19 finding has no edit because bounding the fan-out changes the structure of CheckAll rather than one line — which is what the handoff fix below takes on.

Fix: a CSV ingest pipeline that deadlocks, double-closes a channel and leaks a goroutine per timeout

Two files, go.mod (go 1.22) and ingest/pipeline.go. Parse feeds line numbers to workers over an unbuffered jobs channel that nothing closes, and every worker calls close(out); Lookup sends the fetch result on an unbuffered channel that its select abandons on timeout; Drain spins on a select with an empty default. The free check raises 4 flags (3 high, 1 medium); its reading of the verdict is blocked. This example has no audit before it, so it carries no audit_handoff. The engineer’s note: “Parse hangs in production and sometimes panics with 'close of closed channel'; Lookup leaks goroutines when the partner API is slow. Fix those two, no new dependencies. Leave Drain exactly as it is for now - the status team owns it and is rewriting it next sprint.”

The code string, whole: 1,472 characters, 81 lines ending in a newline. Save it as pipeline-paste.txt and run node build-check.js pipeline-paste.txt > pipeline-check.json:

// file: go.mod
module example.com/ingest

go 1.22
// file: ingest/pipeline.go
package ingest

import (
	"context"
	"errors"
	"strings"
	"sync"
	"time"
)

// Record is one parsed line of a partner's CSV feed.
type Record struct {
	Line   int
	Fields []string
}

// Parse splits lines into records using workers goroutines.
func Parse(lines []string, workers int) []Record {
	jobs := make(chan int)
	out := make(chan Record)
	var wg sync.WaitGroup
	for w := 0; w < workers; w++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for i := range jobs {
				out <- Record{Line: i + 1, Fields: strings.Split(lines[i], ",")}
			}
			close(out)
		}()
	}
	go func() {
		for i := range lines {
			jobs <- i
		}
	}()
	var recs []Record
	for r := range out {
		recs = append(recs, r)
	}
	wg.Wait()
	return recs
}

// Lookup asks the partner API for one record's account, giving up after timeout.
func Lookup(ctx context.Context, fetch func(context.Context, string) (string, error), id string, timeout time.Duration) (string, error) {
	res := make(chan string)
	go func() {
		acct, err := fetch(ctx, id)
		if err != nil {
			return
		}
		res <- acct
	}()
	select {
	case acct := <-res:
		return acct, nil
	case <-time.After(timeout):
		return "", errors.New("lookup timed out")
	}
}

// Drain empties a status channel without blocking the caller.
func Drain(status chan string) int {
	n := 0
	for {
		select {
		case <-status:
			n++
		default:
		}
		if n > 100 {
			return n
		}
	}
}

The flags in its facts, decoded (the other keys are trimmed for display):

{
  "component": {
    "go_version": "1.22",
    "go_files": 1,
    "primitives": [
      "sync",
      "context",
      "time"
    ],
    "goroutines": 3,
    "handlers": 0
  },
  "files": [
    {
      "path": "go.mod",
      "kind": "gomod",
      "line": 2,
      "end_line": 4
    },
    {
      "path": "ingest/pipeline.go",
      "kind": "go",
      "line": 6,
      "end_line": 82
    }
  ],
  ... [trimmed for display: functions, handlers, goroutines, channels, locks, waitgroups, contexts]
  "flags": [
    {
      "uid": "F1",
      "id": "GC-11",
      "sev": "high",
      "file": "ingest/pipeline.go",
      "line": 31,
      "text": "for ... range jobs never ends: nothing in the paste closes jobs",
      "detail": "A range over a channel only stops when the channel is closed. Here the loop blocks after the last value - the goroutine running it leaks, or the whole program deadlocks if it is the main one. The sender closes it (defer close(jobs)) once it is done sending; with several senders, close after their WaitGroup."
    },
    {
      "uid": "F2",
      "id": "GC-12",
      "sev": "high",
      "file": "ingest/pipeline.go",
      "line": 34,
      "text": "close(out) runs in a goroutine started in a loop",
      "detail": "Every iteration's goroutine closes the same channel: the second close panics (close of closed channel), and a send after the first panics too. Close once, from the single sender, after a WaitGroup says every sender is done."
    },
    {
      "uid": "F3",
      "id": "GC-10",
      "sev": "high",
      "file": "ingest/pipeline.go",
      "line": 58,
      "text": "the goroutine's send on res blocks forever once the select leaves by its other case",
      "detail": "res is unbuffered, so the send only completes if someone receives. When the select at line 60 takes the timeout or ctx.Done() case, nobody ever will: one goroutine (and everything it holds) leaks per call. make(chan string, 1) lets the send complete and the goroutine exit."
    },
    {
      "uid": "F4",
      "id": "GC-14",
      "sev": "medium",
      "file": "ingest/pipeline.go",
      "line": 72,
      "text": "the select has an empty default inside a loop, so the loop spins",
      "detail": "When no channel is ready the default runs at once and the loop comes straight back: one core at 100% doing nothing. Drop the default so the select blocks, or block on a ticker or ctx.Done()."
    },
    {
      "uid": "F5",
      "id": "GC-24",
      "sev": "info",
      "file": "ingest/pipeline.go",
      "line": 6,
      "text": "context: 3 goroutine(s), 4 channel(s), 0 lock call(s), 0 derived context(s); go.mod says go 1.22",
      "detail": "Also read: go.mod (gomod). Only what is pasted is checked: a Close, Unlock or Wait that happens in a file you did not paste is outside the check. The page does not run the race detector - go test -race is the ground truth."
    }
  ],
  "verdict_candidate": "blocked",
  "notes": []
}

The request body (Idempotency-Key: goconc-desk:fix:fed85a1a-167f:a1):

{
  "task": "fix",
  "code": "// file: go.mod\nmodule example.com/ingest\n\ngo 1.22\n// file: ingest/pipeline.go\npackage ingest\n\nimport (\n\t\"context\"\n\t\"errors\"\n\t\"strings\"\n\t\"sync\"\n\t\"time\"\n)\n\n// Record is on...",
  "facts": "{\"component\":{\"go_version\":\"1.22\",\"go_files\":1,\"primitives\":[\"sync\",\"context\",\"time\"],\"goroutines\":3,\"handlers\":0},\"files\":[{\"path\":\"go.mod\",\"kind\":\"g...",
  "note": "Parse hangs in production and sometimes panics with 'close of closed channel'; Lookup leaks goroutines when the partner API is slow. Fix those two, no new dependencies. Leave Drain exactly as it is for now - the status team owns it and is rewriting it next sprint."
}

The reply (output.output), whole; files[0].content is the whole fixed file as one JSON string:

{
  "task": "fix",
  "verdict": "partial",
  "headline": "Parse's channel lifecycle and Lookup's goroutine leak are fixed; Drain's busy-spin is left open at the engineer's request.",
  "files": [
    {
      "path": "ingest/pipeline.go",
      "content": "package ingest\n\nimport (\n\t\"context\"\n\t\"errors\"\n\t\"strings\"\n\t\"sync\"\n\t\"time\"\n)\n\n// Record is one parsed line of a partner's CSV feed.\ntype Record struct {\n\tLine   int\n\tFields []string\n}\n\n// Parse splits lines into records using workers goroutines.\nfunc Parse(lines []string, workers int) []Record {\n\tjobs := make(chan int)\n\tout := make(chan Record)\n\tvar wg sync.WaitGroup\n\tfor w := 0; w < workers; w++ {\n\t\twg.Add(1)\n\t\tgo func() {\n\t\t\tdefer wg.Done()\n\t\t\tfor i := range jobs {\n\t\t\t\tout <- Record{Line: i + 1, Fields: strings.Split(lines[i], \",\")}\n\t\t\t}\n\t\t}()\n\t}\n\tgo func() {\n\t\tfor i := range lines {\n\t\t\tjobs <- i\n\t\t}\n\t\tclose(jobs)\n\t}()\n\tgo func() {\n\t\twg.Wait()\n\t\tclose(out)\n\t}()\n\tvar recs []Record\n\tfor r := range out {\n\t\trecs = append(recs, r)\n\t}\n\treturn recs\n}\n\n// Lookup asks the partner API for one record's account, giving up after timeout.\nfunc Lookup(ctx context.Context, fetch func(context.Context, string) (string, error), id string, timeout time.Duration) (string, error) {\n\tres := make(chan string, 1)\n\tgo func() {\n\t\tacct, err := fetch(ctx, id)\n\t\tif err != nil {\n\t\t\treturn\n\t\t}\n\t\tres <- acct\n\t}()\n\tselect {\n\tcase acct := <-res:\n\t\treturn acct, nil\n\tcase <-time.After(timeout):\n\t\treturn \"\", errors.New(\"lookup timed out\")\n\t}\n}\n\n// Drain empties a status channel without blocking the caller.\nfunc Drain(status chan string) int {\n\tn := 0\n\tfor {\n\t\tselect {\n\t\tcase <-status:\n\t\t\tn++\n\t\tdefault:\n\t\t}\n\t\tif n > 100 {\n\t\t\treturn n\n\t\t}\n\t}\n}\n"
    }
  ],
  "changes": [
    {
      "file": "ingest/pipeline.go",
      "function": "Parse",
      "flags": [
        "F1"
      ],
      "change": "the goroutine that feeds jobs now closes jobs itself once it has sent every line index",
      "why": "each worker's for i := range jobs now ends when jobs closes instead of blocking forever after the last job"
    },
    {
      "file": "ingest/pipeline.go",
      "function": "Parse",
      "flags": [
        "F2"
      ],
      "change": "close(out) moved out of the per-worker goroutine into one dedicated goroutine that waits on wg before closing",
      "why": "out is closed exactly once, after every worker has stopped sending, so a second close can no longer panic and no send can race the close"
    },
    {
      "file": "ingest/pipeline.go",
      "function": "Lookup",
      "flags": [
        "F3"
      ],
      "change": "res is now made with a buffer of 1 (make(chan string, 1)) instead of unbuffered",
      "why": "the fetch goroutine's send on res always completes even when Lookup has already returned via the timeout case, so the goroutine exits instead of leaking on every slow call"
    }
  ],
  "verify": [
    "go vet ./...",
    "go test -race ./...",
    "add a test that calls Parse(lines, workers) with workers > 1 on a few dozen lines and asserts it returns within a short deadline (e.g. via a goroutine + select/time.After) with len(recs) == len(lines); run it with -race - this is what would have caught the range-over-jobs deadlock and the double close(out) panic",
    "add a test for Lookup with a fetch func that blocks past timeout, call Lookup in a loop (go test -race -count=50) and check runtime.NumGoroutine() settles back down afterward - this is what would have caught the leaked goroutine on res"
  ],
  "open": [
    {
      "item": "Drain's select still busy-spins on its empty default inside the for loop (GC-14), burning a full core while it waits for status",
      "flags": [
        "F4"
      ],
      "reason": "the note asks to leave Drain exactly as pasted - the status team owns it and is rewriting it next sprint, so changing it here is outside this fix's agreed scope"
    }
  ],
  "questions": [
    "Lookup's goroutine still returns silently when fetch errs (no send on res), so a real fetch error is never surfaced - the caller just sees \"lookup timed out\" after the full timeout elapses. Is that acceptable, or should the real error be propagated back (would need a small result type, outside the leak fix the note asked for)?",
    "Parse assumes workers >= 1. With workers == 0 and a non-empty lines, the feeder goroutine would now block forever sending to the unbuffered jobs channel (nothing reads it) while Parse itself returns an empty slice as soon as out closes - does the caller guarantee workers > 0, or should Parse validate it?"
  ],
  "summary": "The note's two symptoms both check out against the code: nothing closed jobs, so every worker's range over it blocked forever, and every worker's own close(out) meant the second worker to finish would panic with close of closed channel; both are fixed by closing jobs from its sole sender and closing out once, from a goroutine gated on the WaitGroup. Lookup's send on res leaked one goroutine per slow call because res was unbuffered and abandoned once the timeout fired; buffering it by 1 lets that send always complete. No new dependencies were added, only ingest/pipeline.go changed, and Drain was left exactly as pasted per the note - its GC-14 busy-spin (F4) is carried in open."
}

That content, decoded — what the page puts back into the paste under // file: ingest/pipeline.go:

package ingest

import (
	"context"
	"errors"
	"strings"
	"sync"
	"time"
)

// Record is one parsed line of a partner's CSV feed.
type Record struct {
	Line   int
	Fields []string
}

// Parse splits lines into records using workers goroutines.
func Parse(lines []string, workers int) []Record {
	jobs := make(chan int)
	out := make(chan Record)
	var wg sync.WaitGroup
	for w := 0; w < workers; w++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for i := range jobs {
				out <- Record{Line: i + 1, Fields: strings.Split(lines[i], ",")}
			}
		}()
	}
	go func() {
		for i := range lines {
			jobs <- i
		}
		close(jobs)
	}()
	go func() {
		wg.Wait()
		close(out)
	}()
	var recs []Record
	for r := range out {
		recs = append(recs, r)
	}
	return recs
}

// Lookup asks the partner API for one record's account, giving up after timeout.
func Lookup(ctx context.Context, fetch func(context.Context, string) (string, error), id string, timeout time.Duration) (string, error) {
	res := make(chan string, 1)
	go func() {
		acct, err := fetch(ctx, id)
		if err != nil {
			return
		}
		res <- acct
	}()
	select {
	case acct := <-res:
		return acct, nil
	case <-time.After(timeout):
		return "", errors.New("lookup timed out")
	}
}

// Drain empties a status channel without blocking the caller.
func Drain(status chan string) int {
	n := 0
	for {
		select {
		case <-status:
			n++
		default:
		}
		if n > 100 {
			return n
		}
	}
}

The note asked to leave Drain alone, so its GC-14 flag (F4) is carried in open and the verdict is partial, not fixed.

Audit, then fix: the crawler audit handed to the fix lane

After the crawler audit above, the page’s “Apply every edit and fix the rest” ran Recon.fixHandoff on it: 5 edit(s) applied, 0 did not apply. That edited paste is the new code (1,659 characters); its facts, recomputed, raise 1 flag (1 low), and verdict_candidate is now ready. The note is carried over unchanged. CheckAll in the edited paste:

// CheckAll fetches every URL at once and returns the result of each.
func (c *Checker) CheckAll(ctx context.Context, urls []string) map[string]Result {
	results := make(map[string]Result)
	var mu sync.Mutex
	var wg sync.WaitGroup
	failures := 0
	for _, u := range urls {
		wg.Add(1)
		go func(u string) {
			defer wg.Done()
			res := c.check(ctx, u)
			mu.Lock()
			results[u] = res
			if res.Err != nil {
				failures++
			}
			mu.Unlock()
		}(u)
	}
	wg.Wait()
	fmt.Printf("checked %d urls, %d failures\n", len(urls), failures)
	return results
}

The audit_handoff string, decoded:

{
  "verdict": "blocked",
  "headline": "CheckAll spawns unsynchronized goroutines that race on a shared map and counter and can return before they finish, which is the concurrent-map-write crash and the wrong failure count you're seeing.",
  "findings": [
    {
      "id": "GC-02",
      "severity": "high",
      "file": "crawler/crawler.go",
      "line": 41,
      "title": "wg.Add runs inside the goroutine, and it closes over the shared loop variable u",
      "why": "wg.Add(1) runs inside the goroutine, so wg.Wait() on line 50 can see a zero counter before any goroutine has registered and return while checks are still in flight -- the caller then holds a results map and failures count that leftover goroutines are still writing after CheckAll has returned. Because the goroutine reads the loop variable u directly (not a parameter or a copy) and go.mod pins Go 1.21, every goroutine can also see whatever value u has when it runs instead of the URL it was launched for, so some URLs are checked under the wrong key and others never get checked.",
      "edits": 1
    },
    {
      "id": "GC-07",
      "severity": "high",
      "file": "crawler/crawler.go",
      "line": 44,
      "title": "the results map and the failures counter are written from every goroutine with no lock",
      "why": "results[u] = res runs in every one of the per-URL goroutines with no lock: two goroutines writing the same Go map at once is a fatal 'concurrent map writes' runtime error, not just a wrong value, which matches the crash you're seeing. failures++ is a read-modify-write on a shared variable from several goroutines -- a data race that go test -race reports -- so increments are silently lost under load, which is why the printed failure count is always wrong.",
      "edits": 2
    },
    {
      "id": "GC-04",
      "severity": "high",
      "file": "crawler/crawler.go",
      "line": 73,
      "title": "Checker.Checked has a value receiver and copies the mutex it locks",
      "why": "Checked has a value receiver, so c -- including its sync.Mutex -- is copied on every call. Lock/Unlock inside Checked then operate on that copy, not the Checker instance's mutex, so a call to Checked() no longer excludes a concurrent write to checked in check(): go vet's copylocks check flags this, and Checked() can read checked while another goroutine is mid-increment on the real struct.",
      "edits": 1
    },
    {
      "id": "GC-15",
      "severity": "high",
      "file": "crawler/crawler.go",
      "line": 56,
      "title": "the cancel func of context.WithTimeout is discarded",
      "why": "The context and its timer stay referenced until the parent ctx is done (go vet's lostcancel check flags this): with one call per URL and no cancel, this leaks one timer per check() call for as long as the crawl runs, and nothing can free it early once the request completes.",
      "edits": 1
    },
    {
      "id": "GC-19",
      "severity": "low",
      "file": "crawler/crawler.go",
      "line": 40,
      "title": "one goroutine per URL with no limit",
      "why": "CheckAll starts one goroutine per URL with no bound: fine for a short list, but pointed at the whole docs site it opens as many outbound HTTP connections at once as there are URLs, which can exhaust file descriptors or trip the target site's rate limiting. Bound it with errgroup's SetLimit(n) or a fixed-size worker pool reading a jobs channel before running this at scale; the fix is outside these findings' edits since it changes CheckAll's structure rather than one line.",
      "edits": 0
    }
  ],
  "applied": 5,
  "failed": 0
}

The recomputed flags in facts, decoded (the other keys are trimmed for display):

{
  "component": {
    "go_version": "1.21",
    "go_files": 1,
    "primitives": [
      "sync",
      "context",
      "time"
    ],
    "goroutines": 1,
    "handlers": 0
  },
  "files": [
    {
      "path": "go.mod",
      "kind": "gomod",
      "line": 2,
      "end_line": 4
    },
    {
      "path": "crawler/crawler.go",
      "kind": "go",
      "line": 6,
      "end_line": 82
    }
  ],
  ... [trimmed for display: functions, handlers, goroutines, channels, locks, waitgroups, contexts]
  "flags": [
    {
      "uid": "F1",
      "id": "GC-19",
      "sev": "low",
      "file": "crawler/crawler.go",
      "line": 42,
      "text": "one goroutine per item of urls, with no limit",
      "detail": "Fan-out grows with the input: 10,000 items start 10,000 goroutines, each holding a connection or a file. Bound it - errgroup's SetLimit(n), a buffered semaphore channel, or a fixed pool of workers reading a jobs channel."
    },
    {
      "uid": "F2",
      "id": "GC-24",
      "sev": "info",
      "file": "crawler/crawler.go",
      "line": 6,
      "text": "context: 1 goroutine(s), 0 channel(s), 3 lock call(s), 1 derived context(s); go.mod says go 1.21",
      "detail": "Also read: go.mod (gomod). Only what is pasted is checked: a Close, Unlock or Wait that happens in a file you did not paste is outside the check. The page does not run the race detector - go test -race is the ground truth."
    }
  ],
  "verdict_candidate": "ready",
  "notes": []
}

The request body (Idempotency-Key: goconc-desk:fix:713eff9f-1e43:a1):

{
  "task": "fix",
  "code": "// file: go.mod\nmodule example.com/linkcheck\n\ngo 1.21\n// file: crawler/crawler.go\npackage crawler\n\nimport (\n\t\"context\"\n\t\"fmt\"\n\t\"net/http\"\n\t\"sync\"\n\t\"time\"\n)\n\n// Result is ...",
  "facts": "{\"component\":{\"go_version\":\"1.21\",\"go_files\":1,\"primitives\":[\"sync\",\"context\",\"time\"],\"goroutines\":1,\"handlers\":0},\"files\":[{\"path\":\"go.mod\",\"kind\":\"g...",
  "note": "The link checker sometimes crashes with 'concurrent map writes' and the failure count is always wrong. What do we fix before it runs on the whole docs site?",
  "audit_handoff": "{\"verdict\":\"blocked\",\"headline\":\"CheckAll spawns unsynchronized goroutines that race on a shared map and counter and can return before they finish, wh..."
}

The reply (output.output), whole:

{
  "task": "fix",
  "verdict": "fixed",
  "headline": "With the audit's edits already applied, CheckAll's only remaining problem was unbounded fan-out; it now runs at most 20 checks at a time through a buffered semaphore.",
  "files": [
    {
      "path": "crawler/crawler.go",
      "content": "package crawler\n\nimport (\n\t\"context\"\n\t\"fmt\"\n\t\"net/http\"\n\t\"sync\"\n\t\"time\"\n)\n\n// Result is what one URL check found.\ntype Result struct {\n\tURL    string\n\tStatus int\n\tErr    error\n}\n\n// Checker checks the links of the Kestrelmoor docs site.\ntype Checker struct {\n\tclient  *http.Client\n\tmu      sync.Mutex\n\tchecked int\n}\n\nfunc NewChecker() *Checker {\n\treturn &Checker{client: &http.Client{Timeout: 10 * time.Second}}\n}\n\n// maxConcurrentChecks bounds how many URLs CheckAll has in flight at once, so\n// a large site list does not open one outbound connection per URL.\nconst maxConcurrentChecks = 20\n\n// CheckAll fetches every URL, at most maxConcurrentChecks at a time, and\n// returns the result of each.\nfunc (c *Checker) CheckAll(ctx context.Context, urls []string) map[string]Result {\n\tresults := make(map[string]Result)\n\tvar mu sync.Mutex\n\tvar wg sync.WaitGroup\n\tfailures := 0\n\tsem := make(chan struct{}, maxConcurrentChecks)\n\tfor _, u := range urls {\n\t\twg.Add(1)\n\t\tsem <- struct{}{}\n\t\tgo func(u string) {\n\t\t\tdefer wg.Done()\n\t\t\tdefer func() { <-sem }()\n\t\t\tres := c.check(ctx, u)\n\t\t\tmu.Lock()\n\t\t\tresults[u] = res\n\t\t\tif res.Err != nil {\n\t\t\t\tfailures++\n\t\t\t}\n\t\t\tmu.Unlock()\n\t\t}(u)\n\t}\n\twg.Wait()\n\tfmt.Printf(\"checked %d urls, %d failures\\n\", len(urls), failures)\n\treturn results\n}\n\nfunc (c *Checker) check(ctx context.Context, url string) Result {\n\tctx, cancel := context.WithTimeout(ctx, 5*time.Second)\n\tdefer cancel()\n\treq, err := http.NewRequestWithContext(ctx, http.MethodHead, url, nil)\n\tif err != nil {\n\t\treturn Result{URL: url, Err: err}\n\t}\n\tresp, err := c.client.Do(req)\n\tif err != nil {\n\t\treturn Result{URL: url, Err: err}\n\t}\n\tresp.Body.Close()\n\tc.mu.Lock()\n\tc.checked++\n\tc.mu.Unlock()\n\treturn Result{URL: url, Status: resp.StatusCode}\n}\n\n// Checked reports how many URLs have been checked so far.\nfunc (c *Checker) Checked() int {\n\tc.mu.Lock()\n\tdefer c.mu.Unlock()\n\treturn c.checked\n}\n"
    }
  ],
  "changes": [
    {
      "file": "crawler/crawler.go",
      "function": "Checker.CheckAll",
      "flags": [
        "F1"
      ],
      "change": "Added a maxConcurrentChecks buffered channel (size 20) as a semaphore: the loop blocks on sem <- struct{}{} before starting each goroutine, and each goroutine releases it with defer func() { <-sem }().",
      "why": "Prevents the crawl from opening one outbound HTTP connection per URL at once when it runs on the whole docs site, which can exhaust file descriptors or trip the target's rate limiting."
    }
  ],
  "verify": [
    "go vet ./...",
    "go test -race ./...",
    "Write a test that calls CheckAll with a urls slice long enough to exceed maxConcurrentChecks against an httptest.Server that counts concurrent in-flight requests (with a mutex or atomic.Int64) and asserts the peak never exceeds maxConcurrentChecks; run it with -race to also confirm results and failures are written safely.",
    "Write a test with a slice of a few dozen distinct URLs served by an httptest.Server and assert len(CheckAll(ctx, urls)) == len(urls) and Checked() == len(urls), so the earlier lost-write and wrong-count symptoms stay fixed."
  ],
  "open": [],
  "questions": [],
  "summary": "The audit's edits (moving wg.Add before the go statement and passing u as a parameter, locking the results map and failures counter, giving Checked() a pointer receiver, and keeping context.WithTimeout's cancel) are already in the code and check out against it - the concurrent-map-write crash and wrong failure count you saw both trace to the now-fixed unlocked map/counter writes in CheckAll. The one thing the audit left open, unbounded fan-out, is what mattered most for running this on the whole docs site, so this reply bounds CheckAll to 20 checks in flight with a semaphore channel; no exported signature changed. go.mod pins Go 1.21 and no errgroup import is present, so the fix uses a plain WaitGroup, mutex and channel rather than golang.org/x/sync/errgroup."
}

The page checks the reply against the code; the API does not

What comes back from the API is the model’s raw text in output.output. The page holds it to account in the browser before showing it (recon.js reconcile, with the facts, the code and the handoff it sent): it applies every edit or returned file to the paste and re-runs its own checks on the result. None of that happens in the API. A direct API caller gets the reply unchecked and must do the applying and re-checking itself.

• Both lanes: the reply is the lane you asked for (one written for the other task is a disagreement), it carries a valid verdict for that lane, and no credential from the paste is repeated anywhere in it (every credential value the free check found in the paste).
• Audit: the areas table. Exactly four rows, covering lifecycle, shared state, channels and cancellation once each, each with a valid status.
• Audit: every finding is anchored. Its id is in the catalogue (GC-01..GC-24, or other; GC-24 is context and never a finding); its file is a pasted file; its line is inside that file; its evidence is found line by line in that file of code (indentation trimmed) and on or within three lines of line; every cited uid is a non-info flag the page raised. A finding that carries a high flag at a lower severity, or a medium or high finding with no edit, is pointed out.
• Audit: every flag is answered once, consistently. Every non-info flag answered exactly once and no other; a confirmed answer needs a finding carrying that uid; a dismissed one must not be carried by a finding and should give a reason. The verdict must fit the worst severity (blocked with a high finding, needs_work with a medium, otherwise ready).
• Audit: every edit is put in place and re-checked. The findings’ edits are applied in the listed order, each on top of the ones before (Gokit.applyEdits): a before that is not found, is found more than once, or changes nothing is a disagreement. After each finding the free check runs again: the code must still read and no new high flag may appear. With every edit applied, every confirmed flag a finding with edits carries must be gone, every function of the paste must still exist, and a new medium flag is pointed out.
• Fix: the files. At least one file, at most one new one; none empty, none with a // file: line, every path a .go file (or go.mod) and every Go file with its package clause.
• Fix: put into the paste and re-checked. The files replace the pasted files of the same path (or are added) (Gokit.replaceFiles) and the free check runs again: the code must read, no high or medium flag of the paste may remain unless an open item names it, no new high or medium flag may appear, every function must still exist, and every handler must keep its handler signature.
• Fix: the changes list matches the code. Every change names a returned file, a function in the fixed code and real page flags; a high or medium flag no change and no open item names is pointed out. The verdict must fit the open list, and an empty verify is pointed out.

recon.js also runs in Node, so you can hold a reply to exactly the page’s standard. Save /gokit.js and /recon.js next to this script, pass the file you built the body from (build-check.js or handoff.js output), the reply text and the lane; it prints every statement, the count, and the paste with every edit (or file) put back:

// recheck.js -- run: node recheck.js crawler-check.json crawler-reply.txt audit > crawler-edited.txt   (gokit.js, recon.js next to it)
const fs = require("fs");
const Recon = require("./recon.js");                                            // loads ./gokit.js itself
const sent = JSON.parse(fs.readFileSync(process.argv[2], "utf8"));             // code, facts (and audit_handoff) you sent
const lane = process.argv[4] || "audit";
const res = Recon.normalize(Recon.parseResult(fs.readFileSync(process.argv[3], "utf8")), lane);  // output.output
const r = Recon.reconcile(res, { facts: sent.facts, code: sent.code, handoff: sent.audit_handoff || null });
r.notes.forEach((n) => console.error(n.kind + ": " + n.text));
console.error(r.disagreements + " disagreement(s) in " + r.statements + " statements checked");
if (r.after) (r.after.flags || []).forEach((f) => console.error("still raised: " + f.id + " " + f.sev + " " + f.file + ":" + f.line + " " + f.text));
if (r.after && r.after.text) console.log(r.after.text.replace(/\n$/, ""));      // the paste with every edit (or file) put back

For the crawler audit reply it reports:

ok: The areas table rates lifecycle, shared state, channels and cancellation once each.
ok: Every one of the 5 findings names a pasted file, a line inside it and evidence copied from it.
ok: The verdict (blocked) fits the worst finding.
ok: Every one of the page's 7 flags is answered once.
ok: All 5 edits applied in order, each before text found exactly once.
ok: Every confirmed flag a finding carries is gone once all edits are applied.
ok: Every function of the paste is still there after the edits.
ok: The reply repeats no credential from the paste.
0 disagreement(s) in 8 statements checked
still raised: GC-19 low crawler/crawler.go:42 one goroutine per item of urls, with no limit

for the pipeline fix reply (node recheck.js pipeline-check.json pipeline-reply.txt fix):

ok: 1 file returned whole, each with its package clause.
ok: With the fixed files in place the free check raises no high or medium flag beyond the ones left open (0 low).
info: F4 left open by the reply.
ok: Every one of the 3 functions is still there.
ok: Every one of the 3 changes names a returned file, a function in the fixed code and real page flags.
ok: The verdict (partial) fits the open list.
ok: The reply repeats no credential from the paste.
0 disagreement(s) in 6 statements checked
still raised: GC-14 medium ingest/pipeline.go:75 the select has an empty default inside a loop, so the loop spins

and for the crawler handoff fix (node recheck.js crawler-fix-check.json crawler-fix-reply.txt fix):

ok: 1 file returned whole, each with its package clause.
ok: With the fixed files in place the free check raises no high or medium flag (0 low).
ok: Every one of the 4 functions is still there.
ok: Every one of the 1 changes names a returned file, a function in the fixed code and real page flags.
ok: The verdict (fixed) fits the open list.
info: This run carried the audit (5 findings, verdict blocked) with its edits already in the code.
ok: The reply repeats no credential from the paste.
0 disagreement(s) in 6 statements checked

The page does not compile the result and is not the race detector. After that, run go vet ./... and go test -race ./... on the edited code, plus the tests the reply’s plan or verify names, before you ship anything.

Step 1 — a tiny client helper

One function per language that does what sdk.js does for every call: JSON in, bearer token if you have one, data out on a 2xx, an error carrying status, error.code and error.message otherwise. The later steps assume this helper is in the same file (for Go, Java and C#, the later snippets go inside main / the top-level statements; Java’s makeInput from step 4 goes in the class).

BASE="https://api.skillsafe.ai/v1/app-api"
TOKEN="${SKILLSAFE_TOKEN:-YOUR_TOKEN}"   # step 2

# api METHOD PATH [extra curl args...] -- prints the whole envelope; pipe to jq
api() {
  method="$1"; path="$2"; shift 2
  curl -sS -X "$method" "$BASE$path" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $TOKEN" "$@"
}
# success: jq '.data'      failure: jq '.error | {code, message}'

import hashlib, json, os, time, urllib.parse
import requests  # pip install requests

BASE = "https://api.skillsafe.ai/v1/app-api"
TOKEN = os.environ.get("SKILLSAFE_TOKEN", "YOUR_TOKEN")  # step 2


class ApiError(Exception):
    def __init__(self, status, code, message, details=None):
        super().__init__(f"{status} {code}: {message}")
        self.status, self.code, self.details = status, code, details


def api(method, path, body=None, headers=None):
    h = {"Content-Type": "application/json"}
    if TOKEN:
        h["Authorization"] = "Bearer " + TOKEN
    h.update(headers or {})
    r = requests.request(method, BASE + path, headers=h,
                         data=None if body is None else json.dumps(body))
    try:
        env = r.json()
    except ValueError:
        env = {}
    if not r.ok:
        err = env.get("error") or {}
        raise ApiError(r.status_code, err.get("code"), err.get("message") or r.reason, err.get("details"))
    return env.get("data")

// goconc-desk.mjs -- Node 18+ (global fetch), run with: node goconc-desk.mjs
import { readFileSync } from "node:fs";
import { createHash } from "node:crypto";

const BASE = "https://api.skillsafe.ai/v1/app-api";
let TOKEN = "YOUR_TOKEN"; // step 2

async function api(method, path, body, headers = {}) {
  const h = { "Content-Type": "application/json", ...headers };
  if (TOKEN) h.Authorization = "Bearer " + TOKEN;
  const res = await fetch(BASE + path, {
    method,
    headers: h,
    body: body === undefined ? undefined : JSON.stringify(body),
  });
  const json = await res.json().catch(() => ({}));
  if (!res.ok) {
    const err = new Error((json.error && json.error.message) || res.statusText);
    err.status = res.status;
    err.code = json.error && json.error.code;
    err.details = json.error && json.error.details;
    throw err;
  }
  return json.data;
}

package main

import (
	"bufio"
	"bytes"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"
	"os"
	"strings"
	"time"
)

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

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

type apiError struct {
	Status  int
	Code    string
	Message string
}

func (e *apiError) Error() string { return fmt.Sprintf("%d %s: %s", e.Status, e.Code, e.Message) }

type envelope struct {
	OK    bool            `json:"ok"`
	Data  json.RawMessage `json:"data"`
	Error *struct {
		Code    string `json:"code"`
		Message string `json:"message"`
	} `json:"error"`
}

func newRequest(method, path string, body any, headers map[string]string) (*http.Request, error) {
	var buf []byte
	if body != nil {
		b, err := json.Marshal(body)
		if err != nil {
			return nil, err
		}
		buf = b
	}
	req, err := http.NewRequest(method, base+path, bytes.NewReader(buf))
	if err != nil {
		return nil, err
	}
	req.Header.Set("Content-Type", "application/json")
	if token != "" {
		req.Header.Set("Authorization", "Bearer "+token)
	}
	for k, v := range headers {
		req.Header.Set(k, v)
	}
	return req, nil
}

func errorFrom(res *http.Response, env envelope) error {
	e := &apiError{Status: res.StatusCode, Message: http.StatusText(res.StatusCode)}
	if env.Error != nil {
		e.Code = env.Error.Code
		if env.Error.Message != "" {
			e.Message = env.Error.Message
		}
	}
	return e
}

// api sends body as JSON and decodes the envelope's data into out (out may be nil).
func api(method, path string, body any, headers map[string]string, out any) error {
	req, err := newRequest(method, path, body, headers)
	if err != nil {
		return err
	}
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		return err
	}
	defer res.Body.Close()
	var env envelope
	_ = json.NewDecoder(res.Body).Decode(&env)
	if res.StatusCode < 200 || res.StatusCode > 299 {
		return errorFrom(res, env)
	}
	if out != nil && len(env.Data) > 0 {
		return json.Unmarshal(env.Data, out)
	}
	return nil
}

func main() {
	// steps 2-6 go here; remove any import a step you skip no longer uses
	_, _, _, _, _ = bufio.NewScanner, sha256.Sum256, hex.EncodeToString, url.PathEscape, strings.Index
	_ = time.Second
}

// GoConcDesk.java -- Java 17+, needs com.fasterxml.jackson.core:jackson-databind on the classpath
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.security.MessageDigest;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class GoConcDesk {
  static final String BASE = "https://api.skillsafe.ai/v1/app-api";
  static String token = System.getenv().getOrDefault("SKILLSAFE_TOKEN", "YOUR_TOKEN"); // step 2
  static final HttpClient HTTP = HttpClient.newHttpClient();
  static final ObjectMapper JSON = new ObjectMapper();

  static class ApiException extends Exception {
    final int status;
    final String code;
    ApiException(int status, String code, String message) {
      super(status + " " + code + ": " + message);
      this.status = status;
      this.code = code;
    }
  }

  static HttpRequest.Builder request(String method, String path, Object body, Map<String, String> headers) throws Exception {
    HttpRequest.Builder b = HttpRequest.newBuilder(URI.create(BASE + path))
        .header("Content-Type", "application/json")
        .method(method, body == null ? HttpRequest.BodyPublishers.noBody()
                                     : HttpRequest.BodyPublishers.ofString(JSON.writeValueAsString(body)));
    if (token != null && !token.isEmpty()) b.header("Authorization", "Bearer " + token);
    if (headers != null) headers.forEach(b::header);
    return b;
  }

  static ApiException errorFrom(int status, JsonNode env) {
    JsonNode err = env.path("error");
    return new ApiException(status, err.path("code").asText(null), err.path("message").asText("HTTP " + status));
  }

  static JsonNode api(String method, String path, Object body, Map<String, String> headers) throws Exception {
    HttpResponse<String> res = HTTP.send(request(method, path, body, headers).build(), HttpResponse.BodyHandlers.ofString());
    JsonNode env;
    try { env = JSON.readTree(res.body()); } catch (Exception e) { env = JSON.createObjectNode(); }
    if (env == null) env = JSON.createObjectNode();
    if (res.statusCode() / 100 != 2) throw errorFrom(res.statusCode(), env);
    return env.path("data");
  }

  public static void main(String[] args) throws Exception {
    // steps 2-6 go here (makeInput from step 4 goes next to api())
  }
}

require "digest"
require "json"
require "net/http"
require "uri"

BASE = "https://api.skillsafe.ai/v1/app-api"
$token = ENV.fetch("SKILLSAFE_TOKEN", "YOUR_TOKEN") # step 2

class ApiError < StandardError
  attr_reader :status, :code
  def initialize(status, code, message)
    super("#{status} #{code}: #{message}")
    @status = status
    @code = code
  end
end

def build_request(method, path, body = nil, headers = {})
  uri = URI(BASE + path)
  req = Net::HTTPGenericRequest.new(method, !body.nil?, true, uri.request_uri)
  req["Content-Type"] = "application/json"
  req["Authorization"] = "Bearer #{$token}" if $token && !$token.empty?
  headers.each { |k, v| req[k] = v }
  req.body = JSON.generate(body) unless body.nil?
  [uri, req]
end

def api(method, path, body = nil, headers = {})
  uri, req = build_request(method, path, body, headers)
  res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
  env = (JSON.parse(res.body) rescue {})
  env = {} unless env.is_a?(Hash)
  unless res.is_a?(Net::HTTPSuccess)
    err = env["error"] || {}
    raise ApiError.new(res.code.to_i, err["code"], err["message"] || res.message)
  end
  env["data"]
end

<?php
// needs the curl extension
const BASE = "https://api.skillsafe.ai/v1/app-api";
$TOKEN = getenv("SKILLSAFE_TOKEN") ?: "YOUR_TOKEN"; // step 2

class ApiError extends Exception {
    public $status;
    public $apiCode;
    public function __construct($status, $code, $message) {
        parent::__construct("$status $code: $message");
        $this->status = $status;
        $this->apiCode = $code;
    }
}

function headers_for(array $extra = []): array {
    global $TOKEN;
    $h = ["Content-Type: application/json"];
    if ($TOKEN) $h[] = "Authorization: Bearer $TOKEN";
    foreach ($extra as $k => $v) $h[] = "$k: $v";
    return $h;
}

function api(string $method, string $path, $body = null, array $headers = []) {
    $ch = curl_init(BASE . $path);
    curl_setopt_array($ch, [
        CURLOPT_CUSTOMREQUEST => $method,
        CURLOPT_HTTPHEADER => headers_for($headers),
        CURLOPT_RETURNTRANSFER => true,
    ]);
    if ($body !== null) curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($body, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE));
    $raw = curl_exec($ch);
    if ($raw === false) throw new RuntimeException(curl_error($ch));
    $status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
    curl_close($ch);
    $env = json_decode($raw);
    if (!is_object($env)) $env = new stdClass();
    if ($status < 200 || $status > 299) {
        $e = $env->error ?? new stdClass();
        throw new ApiError($status, $e->code ?? null, $e->message ?? "HTTP $status");
    }
    return $env->data ?? null;
}

// Program.cs -- .NET 6+ console app (implicit usings on) with top-level statements; steps 2-6 (with the MakeInput local function) go ABOVE this class
using System.Text;
using System.Text.Json;
using System.Text.Json.Nodes;

static class Api
{
    public const string Base = "https://api.skillsafe.ai/v1/app-api";
    public static string Token = Environment.GetEnvironmentVariable("SKILLSAFE_TOKEN") ?? "YOUR_TOKEN"; // step 2
    public static readonly HttpClient Http = new HttpClient();

    public class ApiException : Exception
    {
        public int Status;
        public string? Code;
        public ApiException(int status, string? code, string message) : base($"{status} {code}: {message}")
        {
            Status = status;
            Code = code;
        }
    }

    public static HttpRequestMessage Request(string method, string path, object? body = null, IDictionary<string, string>? headers = null)
    {
        var req = new HttpRequestMessage(new HttpMethod(method), Base + path);
        if (body != null) req.Content = new StringContent(JsonSerializer.Serialize(body), Encoding.UTF8, "application/json");
        if (!string.IsNullOrEmpty(Token)) req.Headers.TryAddWithoutValidation("Authorization", "Bearer " + Token);
        if (headers != null) foreach (var kv in headers) req.Headers.TryAddWithoutValidation(kv.Key, kv.Value);
        return req;
    }

    public static ApiException ErrorFrom(HttpResponseMessage res, JsonNode? env)
    {
        var err = env?["error"];
        return new ApiException((int)res.StatusCode, err?["code"]?.GetValue<string>(),
            err?["message"]?.GetValue<string>() ?? res.ReasonPhrase ?? "error");
    }

    public static async Task<JsonNode?> Call(string method, string path, object? body = null, IDictionary<string, string>? headers = null)
    {
        using var req = Request(method, path, body, headers);
        using var res = await Http.SendAsync(req);
        var text = await res.Content.ReadAsStringAsync();
        JsonNode? env = null;
        try { env = JsonNode.Parse(text); } catch (JsonException) { }
        if (!res.IsSuccessStatusCode) throw ErrorFrom(res, env);
        return env?["data"];
    }
}

Step 2 — a token

Two kinds work:

• Personal — needed for a run. Both lanes are metered in credits on gpt-terra, so a run needs a signed-in (user) token (the page says “The audit run is metered, so it needs an account.”, or the same of the fix run) unless the estimate says sponsor_enabled. Sign in and copy your token from /tokens.html, then export it as SKILLSAFE_TOKEN (the samples fall back to the placeholder YOUR_TOKEN).
• Guest — enough for /me and /estimate. POST /guest with {"slug": "goconc-desk"} and no Authorization header, exactly as sdk.js guest() does. The response’s data carries token and guest_id. Reuse a token you already hold rather than minting a new one each time.

# personal token (needed for a run): copy it from /tokens.html, then
#   export SKILLSAFE_TOKEN=...        and skip the rest of this block
# guest token (enough for /me and /estimate): no Authorization header on this one call
TOKEN=$(curl -sS -X POST "$BASE/guest" \
  -H "Content-Type: application/json" \
  -d '{"slug":"goconc-desk"}' | jq -r '.data.token')
echo "guest token: ${TOKEN:0:12}..."

# personal token (needed for a run): set SKILLSAFE_TOKEN (from /tokens.html) and skip this
if TOKEN in ("", "YOUR_TOKEN"):
    TOKEN = ""                      # no Authorization header on /guest
    guest = api("POST", "/guest", {"slug": "goconc-desk"})
    TOKEN = guest["token"]
    print("guest", guest.get("guest_id"))

// personal token (needed for a run): paste it from /tokens.html into TOKEN and skip this
if (!TOKEN || TOKEN === "YOUR_TOKEN") {
  TOKEN = "";                       // no Authorization header on /guest
  const guest = await api("POST", "/guest", { slug: "goconc-desk" });
  TOKEN = guest.token;
  console.log("guest", guest.guest_id);
}

// inside main -- personal token (needed for a run): set SKILLSAFE_TOKEN (from /tokens.html) and skip this
if token == "" {
	var guest struct {
		Token   string `json:"token"`
		GuestID string `json:"guest_id"`
	}
	if err := api("POST", "/guest", map[string]string{"slug": "goconc-desk"}, nil, &guest); err != nil {
		panic(err)
	}
	token = guest.Token
	fmt.Println("guest", guest.GuestID)
}

// inside main -- personal token (needed for a run): set SKILLSAFE_TOKEN (from /tokens.html) and skip this
if (token.isEmpty() || token.equals("YOUR_TOKEN")) {
  token = "";                       // no Authorization header on /guest
  JsonNode guest = api("POST", "/guest", Map.of("slug", "goconc-desk"), null);
  token = guest.path("token").asText();
  System.out.println("guest " + guest.path("guest_id").asText());
}

# personal token (needed for a run): set SKILLSAFE_TOKEN (from /tokens.html) and skip this
if $token.empty? || $token == "YOUR_TOKEN"
  $token = ""                       # no Authorization header on /guest
  guest = api("POST", "/guest", { slug: "goconc-desk" })
  $token = guest["token"]
  puts "guest #{guest["guest_id"]}"
end

// personal token (needed for a run): set SKILLSAFE_TOKEN (from /tokens.html) and skip this
if ($TOKEN === "" || $TOKEN === "YOUR_TOKEN") {
    $TOKEN = "";                    // no Authorization header on /guest
    $guest = api("POST", "/guest", ["slug" => "goconc-desk"]);
    $TOKEN = $guest->token;
    echo "guest {$guest->guest_id}\n";
}

// top-level statements (above the Api class) -- personal token (needed for a run): set SKILLSAFE_TOKEN (from /tokens.html) and skip this
if (Api.Token == "" || Api.Token == "YOUR_TOKEN")
{
    Api.Token = "";                 // no Authorization header on /guest
    var guest = await Api.Call("POST", "/guest", new { slug = "goconc-desk" });
    Api.Token = guest!["token"]!.GetValue<string>();
    Console.WriteLine($"guest {guest["guest_id"]}");
}

Step 3 — GET /me

Who the token belongs to and what it can spend. sdk.js documents the shape as {subject_type, subject_id, credits, profile?}. The page treats the caller as signed in only when subject_type is "user", shows credits as the balance (1 credit = $0.0001, so it divides by 10 000 for the dollar figure), and compares it with the estimate in step 4 before it lets you run.

api GET /me | jq '.data // .error'

me = api("GET", "/me")
print(me["subject_type"], me.get("subject_id"), me.get("credits"))
signed_in = me["subject_type"] == "user"

const me = await api("GET", "/me");
console.log(me.subject_type, me.subject_id, me.credits);
const signedIn = me.subject_type === "user";

var me struct {
	SubjectType string `json:"subject_type"`
	SubjectID   any    `json:"subject_id"`
	Credits     any    `json:"credits"`
}
if err := api("GET", "/me", nil, nil, &me); err != nil {
	panic(err)
}
fmt.Println(me.SubjectType, me.SubjectID, me.Credits)
signedIn := me.SubjectType == "user"
_ = signedIn

JsonNode me = api("GET", "/me", null, null);
System.out.println(me.path("subject_type").asText() + " " + me.path("subject_id").asText() + " " + me.path("credits"));
boolean signedIn = me.path("subject_type").asText().equals("user");

me = api("GET", "/me")
puts [me["subject_type"], me["subject_id"], me["credits"]].join(" ")
signed_in = me["subject_type"] == "user"

$me = api("GET", "/me");
echo $me->subject_type, " ", $me->subject_id ?? "", " ", $me->credits ?? "", "\n";
$signedIn = $me->subject_type === "user";

var me = await Api.Call("GET", "/me");
Console.WriteLine($"{me?["subject_type"]} {me?["subject_id"]} {me?["credits"]}");
var signedIn = me?["subject_type"]?.GetValue<string>() == "user";

Step 4 — build the input, then POST /estimate

First a small makeInput that does what buildInput does: task, then code as the paste the page would send, facts as a compact JSON string, the note when it is not blank, and — for the fix lane only — the audit_handoff string when the file carries one. It reads the file build-check.js (or handoff.js) printed. The samples build the audit input of the crawler example from crawler-check.json; step 6 reuses makeInput for the pipeline (fix) example. Then price it. The body of /estimate is the same input you will send to /run; no job is created and nothing is charged — /estimate is free. From the response the page reads:

The page re-prices whenever the paste, the note or the lane change. The amounts grow with the size of code and facts, so read them from the call rather than hard-coding them.

# crawler-check.json: printed by build-check.js (see "The facts string").
# (.facts | tojson) turns the facts into ONE compact string, as JSON.stringify does.
BODY=$(jq -c --arg note "The link checker sometimes crashes with 'concurrent map writes' and the failure count is always wrong. What do we fix before it runs on the whole docs site?" \
  '{task: "audit", code, facts: (.facts | tojson), note: $note}' crawler-check.json)
# No page check at hand? facts: "{}" is accepted as a string, but the reply then has no page flags to answer.
# Fix lane after an audit: read handoff.js's output instead and add its string:
#   '{task: "fix", code, facts: (.facts | tojson), note: $note} + (if .audit_handoff then {audit_handoff} else {} end)'

api POST /estimate -d "$BODY" \
  | jq '.error // (.data | {hold_credits, min_credits, sponsor_enabled, warnings})'

def make_input(task, check_path, note=None):
    """The body the page sends: task, code, facts as a JSON STRING, an optional note, and
    (fix lane only) the audit_handoff string -- every value a string."""
    with open(check_path, encoding="utf-8") as f:
        check = json.load(f)                    # build-check.js (or handoff.js) output
    inp = {
        "task": task,
        "code": check["code"],                  # the paste as the page sends it
        "facts": json.dumps(check["facts"], separators=(",", ":"), ensure_ascii=False),  # a STRING, like JSON.stringify
    }
    n = (note or "").strip()
    if n:
        inp["note"] = n[:2000]                  # optional; the page caps it at 2000 chars
    if task == "fix" and check.get("audit_handoff"):
        inp["audit_handoff"] = check["audit_handoff"]   # optional; already a JSON string
    return inp


inp = make_input("audit", "crawler-check.json",
                 "The link checker sometimes crashes with 'concurrent map writes' and the failure count is always wrong. What do we fix before it runs on the whole docs site?")

est = api("POST", "/estimate", inp)
print("hold", est.get("hold_credits"), "min", est.get("min_credits"),
      "sponsored", est.get("sponsor_enabled"), "warnings", est.get("warnings") or [])

// The body the page sends: task, code, facts as a JSON STRING, an optional note,
// and (fix lane only) the audit_handoff string -- every value a string.
function makeInput(task, checkPath, note) {
  const check = JSON.parse(readFileSync(checkPath, "utf8"));          // build-check.js (or handoff.js) output
  const input = {
    task,
    code: check.code,                                                 // the paste as the page sends it
    facts: JSON.stringify(check.facts),                               // a STRING: the page's free check
  };
  const n = (note || "").trim();
  if (n) input.note = n.length > 2000 ? n.slice(0, 2000) : n;         // optional; max 2000 chars
  if (task === "fix" && check.audit_handoff) input.audit_handoff = check.audit_handoff;  // optional
  return input;
}

const input = makeInput("audit", "crawler-check.json",
  "The link checker sometimes crashes with 'concurrent map writes' and the failure count is always wrong. What do we fix before it runs on the whole docs site?");

const est = await api("POST", "/estimate", input);
console.log("hold", est.hold_credits, "min", est.min_credits,
  "sponsored", est.sponsor_enabled, "warnings", est.warnings || []);

// makeInput builds the body the page sends: task, code, facts as a JSON STRING,
// an optional note and (fix lane only) the audit_handoff string.
makeInput := func(task, checkPath, note string) map[string]any {
	raw, err := os.ReadFile(checkPath) // build-check.js (or handoff.js) output
	if err != nil {
		panic(err)
	}
	var check struct {
		Code         string          `json:"code"`
		Facts        json.RawMessage `json:"facts"`
		AuditHandoff string          `json:"audit_handoff"`
	}
	if err := json.Unmarshal(raw, &check); err != nil {
		panic(err)
	}
	var facts bytes.Buffer
	if err := json.Compact(&facts, check.Facts); err != nil { // keeps key order; travels as a STRING
		panic(err)
	}
	in := map[string]any{"task": task, "code": check.Code, "facts": facts.String()}
	if n := []rune(strings.TrimSpace(note)); len(n) > 0 {
		if len(n) > 2000 {
			n = n[:2000] // optional; the page caps it at 2000 chars
		}
		in["note"] = string(n)
	}
	if task == "fix" && check.AuditHandoff != "" {
		in["audit_handoff"] = check.AuditHandoff // optional; already a JSON string
	}
	return in
}

input := makeInput("audit", "crawler-check.json",
	"The link checker sometimes crashes with 'concurrent map writes' and the failure count is always wrong. What do we fix before it runs on the whole docs site?")

var est struct {
	HoldCredits    any   `json:"hold_credits"`
	MinCredits     any   `json:"min_credits"`
	SponsorEnabled bool  `json:"sponsor_enabled"`
	Warnings       []any `json:"warnings"`
}
if err := api("POST", "/estimate", input, nil, &est); err != nil {
	panic(err)
}
fmt.Printf("hold %v min %v sponsored %v warnings %v\n", est.HoldCredits, est.MinCredits, est.SponsorEnabled, est.Warnings)

// ---- add to the GoConcDesk class, next to api(): the body the page sends
static Map<String, Object> makeInput(String task, String checkPath, String note) throws Exception {
  JsonNode check = JSON.readTree(Files.readString(Path.of(checkPath)));        // build-check.js (or handoff.js) output
  Map<String, Object> in = new LinkedHashMap<>();
  in.put("task", task);
  in.put("code", check.path("code").asText());                                 // the paste as the page sends it
  in.put("facts", JSON.writeValueAsString(check.path("facts")));               // a STRING, compact
  String n = note == null ? "" : note.strip();
  if (!n.isEmpty()) in.put("note", n.length() > 2000 ? n.substring(0, 2000) : n);  // optional; max 2000 chars
  if (task.equals("fix") && check.hasNonNull("audit_handoff")) in.put("audit_handoff", check.get("audit_handoff").asText());
  return in;
}

// ---- inside main
Map<String, Object> input = makeInput("audit", "crawler-check.json",
    "The link checker sometimes crashes with 'concurrent map writes' and the failure count is always wrong. What do we fix before it runs on the whole docs site?");

JsonNode est = api("POST", "/estimate", input, null);
System.out.println("hold " + est.path("hold_credits") + " min " + est.path("min_credits")
    + " sponsored " + est.path("sponsor_enabled").asBoolean(false) + " warnings " + est.path("warnings"));

# The body the page sends: task, code, facts as a JSON STRING, an optional note,
# and (fix lane only) the audit_handoff string -- every value a string.
def make_input(task, check_path, note = nil)
  check = JSON.parse(File.read(check_path, encoding: "UTF-8"))   # build-check.js (or handoff.js) output
  input = {
    task: task,
    code: check["code"],                                            # the paste as the page sends it
    facts: JSON.generate(check["facts"])                            # a STRING, compact
  }
  n = note.to_s.strip
  input[:note] = n[0, 2000] unless n.empty?                         # optional; max 2000 chars
  input[:audit_handoff] = check["audit_handoff"] if task == "fix" && !check["audit_handoff"].to_s.empty?
  input
end

input = make_input("audit", "crawler-check.json",
                   "The link checker sometimes crashes with 'concurrent map writes' and the failure count is always wrong. What do we fix before it runs on the whole docs site?")

est = api("POST", "/estimate", input)
puts "hold #{est["hold_credits"]} min #{est["min_credits"]} " \
     "sponsored #{est["sponsor_enabled"]} warnings #{(est["warnings"] || []).inspect}"

// The body the page sends: task, code, facts as a JSON STRING, an optional note,
// and (fix lane only) the audit_handoff string -- every value a string.
function make_input(string $task, string $checkPath, string $note = ""): array {
    // decode to objects (not arrays) so an empty {} stays {} when re-encoded
    $check = json_decode(file_get_contents($checkPath));          // build-check.js (or handoff.js) output
    $input = [
        "task" => $task,
        "code" => $check->code,                                    // the paste as the page sends it
        "facts" => json_encode($check->facts, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE),  // a STRING
    ];
    $n = trim($note);
    if ($n !== "") $input["note"] = mb_substr($n, 0, 2000);        // optional; max 2000 chars
    if ($task === "fix" && !empty($check->audit_handoff)) $input["audit_handoff"] = $check->audit_handoff;
    return $input;
}

$input = make_input("audit", "crawler-check.json",
    "The link checker sometimes crashes with 'concurrent map writes' and the failure count is always wrong. What do we fix before it runs on the whole docs site?");

$est = api("POST", "/estimate", $input);
echo "hold ", $est->hold_credits ?? "-", " min ", $est->min_credits ?? "-",
     " sponsored ", json_encode($est->sponsor_enabled ?? false),
     " warnings ", json_encode($est->warnings ?? []), "\n";

// The body the page sends: task, code, facts as a JSON STRING, an optional note,
// and (fix lane only) the audit_handoff string -- every value a string.
static Dictionary<string, string> MakeInput(string task, string checkPath, string? note = null)
{
    var compact = new JsonSerializerOptions { Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping };
    var check = JsonNode.Parse(File.ReadAllText(checkPath))!;               // build-check.js (or handoff.js) output
    var input = new Dictionary<string, string>
    {
        ["task"] = task,
        ["code"] = check["code"]!.GetValue<string>(),                         // the paste as the page sends it
        ["facts"] = check["facts"]!.ToJsonString(compact),                    // a STRING, compact
    };
    var n = (note ?? "").Trim();
    if (n.Length > 0) input["note"] = n.Length > 2000 ? n[..2000] : n;       // optional; max 2000 chars
    var handoff = check["audit_handoff"]?.GetValue<string>();
    if (task == "fix" && !string.IsNullOrEmpty(handoff)) input["audit_handoff"] = handoff;
    return input;
}

var input = MakeInput("audit", "crawler-check.json",
    "The link checker sometimes crashes with 'concurrent map writes' and the failure count is always wrong. What do we fix before it runs on the whole docs site?");

var est = await Api.Call("POST", "/estimate", input);
Console.WriteLine($"hold {est?["hold_credits"]} min {est?["min_credits"]} " +
    $"sponsored {est?["sponsor_enabled"]} warnings {est?["warnings"]?.ToJsonString() ?? "[]"}");

Step 5 — POST /run, then poll the job (audit)

Send the same input to /run with an Idempotency-Key header, using a personal token. Its data carries a job_id. Poll GET /jobs/{job_id} the way sdk.js waitForJob does: every second until status is succeeded or failed, giving up on the client side after 180 seconds. On the finished job, read:

• output.output — the model’s reply as a string: the JSON object from the output contract of the lane you asked for. Parse it yourself (from the first { to the last }). The samples print the verdict and headline, each area’s status, each finding’s id, file, line, severity and number of edits, then each flag answer. Keep the text: recheck.js reads it.
• truncated — true when the reply was cut short because the balance ran out. The page then closes the cut-off JSON, shows what arrived as a partial result (“N of 9 sections recovered” for an audit, of 8 for a fix run), and says it was cut short by the available balance.
• charged_credits — the real cost of the run, as opposed to the estimate’s hold_credits reservation. The page re-reads /me afterwards for the new balance.
• error — on a failed job.

Idempotency key. Resending a request with the same key must not start a second paid run, so derive the key from the input, not from the clock — and include the lane, so an audit and a fix run of the same paste never share a key. The page uses goconc-desk:<lane>:<inputHash>:a<attempt> (app.js run), where <lane> is audit or fix, <inputHash> is a 32-bit djb2 hash of JSON.stringify(input) in hex, a dash, and the string’s length in hex (app.js inputHash, over the input without retry_note), and <attempt> is 1 for a normal run and 2 for the automatic reformat retry (which also adds retry_note). For the three worked examples that is goconc-desk:audit:fb06d86d-1942:a1 (crawler audit), goconc-desk:fix:fed85a1a-167f:a1 (pipeline fix) and goconc-desk:fix:713eff9f-1e43:a1 (the crawler handoff fix). The format is the page’s convention, not a requirement: any stable, unique string does. The samples below use the lane and a SHA-256 prefix.

The page itself uses /run-stream (step 6), not /run; both take the same body and header.

KEY="goconc-desk:audit:$(printf '%s' "$BODY" | shasum -a 256 | cut -c1-16):a1"

JOB=$(api POST /run -H "Idempotency-Key: $KEY" -d "$BODY" | jq -r '.data.job_id')

for i in $(seq 180); do                       # 1 s interval, 180 s client-side limit
  J=$(api GET "/jobs/$JOB")
  S=$(printf '%s' "$J" | jq -r '.data.status')
  if [ "$S" = "succeeded" ] || [ "$S" = "failed" ]; then break; fi
  sleep 1
done

printf '%s' "$J" | jq '.data | {status, truncated, charged_credits, error}'
printf '%s' "$J" | jq -r '.data.output.output' \
  | jq '{verdict, headline, areas: [(.areas // [])[] | {area, status}],
         findings: [(.findings // [])[] | {id, file, line, severity, edits: ((.edits // []) | length)}],
         flag_answers: [(.flag_answers // [])[] | {flag, status}]}'

body = json.dumps(inp)
key = "goconc-desk:audit:" + hashlib.sha256(body.encode()).hexdigest()[:16] + ":a1"

job_id = api("POST", "/run", inp, {"Idempotency-Key": key})["job_id"]

deadline = time.time() + 180                    # 1 s interval, 180 s client-side limit
while True:
    job = api("GET", "/jobs/" + urllib.parse.quote(job_id, safe=""))
    if job["status"] in ("succeeded", "failed"):
        break
    if time.time() > deadline:
        raise TimeoutError("job timed out")
    time.sleep(1)

if job["status"] == "failed":
    raise SystemExit(f"run failed: {job.get('error')}")

print("truncated:", job.get("truncated") is True, "charged:", job.get("charged_credits"))
text = (job.get("output") or {}).get("output") or ""
reply = json.loads(text[text.index("{"): text.rindex("}") + 1])
print(reply["verdict"], "-", reply["headline"])
for s in reply.get("areas", []):
    print("area", s["area"], s["status"])
for f in reply.get("findings", []):
    print(f["id"], f["file"], f.get("line"), f["severity"], len(f.get("edits") or []), "edit(s)")
for a in reply.get("flag_answers", []):
    print("answer", a["flag"], a["status"])

const key = "goconc-desk:audit:" +
  createHash("sha256").update(JSON.stringify(input)).digest("hex").slice(0, 16) + ":a1";

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

let job;
const deadline = Date.now() + 180000;           // 1 s interval, 180 s client-side limit
for (;;) {
  job = await api("GET", "/jobs/" + encodeURIComponent(job_id));
  if (job.status === "succeeded" || job.status === "failed") break;
  if (Date.now() > deadline) throw new Error("job timed out");
  await new Promise((r) => setTimeout(r, 1000));
}
if (job.status === "failed") throw new Error("run failed: " + JSON.stringify(job.error));

console.log("truncated:", job.truncated === true, "charged:", job.charged_credits);
const text = (job.output && job.output.output) || "";
const reply = JSON.parse(text.slice(text.indexOf("{"), text.lastIndexOf("}") + 1));
console.log(reply.verdict, "-", reply.headline);
for (const s of reply.areas || []) console.log("area", s.area, s.status);
for (const f of reply.findings || []) console.log(f.id, f.file, f.line, f.severity, (f.edits || []).length, "edit(s)");
for (const a of reply.flag_answers || []) console.log("answer", a.flag, a.status);

inputJSON, _ := json.Marshal(input)
sum := sha256.Sum256(inputJSON)
key := "goconc-desk:audit:" + hex.EncodeToString(sum[:8]) + ":a1"

var started struct {
	JobID string `json:"job_id"`
}
if err := api("POST", "/run", input, map[string]string{"Idempotency-Key": key}, &started); err != nil {
	panic(err)
}

type jobT struct {
	Status string `json:"status"`
	Output *struct {
		Output string `json:"output"`
	} `json:"output"`
	Truncated      bool `json:"truncated"`
	ChargedCredits any  `json:"charged_credits"`
	Error          any  `json:"error"`
}
var job jobT
deadline := time.Now().Add(180 * time.Second) // 1 s interval, 180 s client-side limit
for {
	job = jobT{}
	if err := api("GET", "/jobs/"+url.PathEscape(started.JobID), nil, nil, &job); err != nil {
		panic(err)
	}
	if job.Status == "succeeded" || job.Status == "failed" {
		break
	}
	if time.Now().After(deadline) {
		panic("job timed out")
	}
	time.Sleep(time.Second)
}
if job.Status == "failed" {
	panic(fmt.Sprintf("run failed: %v", job.Error))
}

fmt.Println("truncated:", job.Truncated, "charged:", job.ChargedCredits)
text := ""
if job.Output != nil {
	text = job.Output.Output
}
var reply map[string]any
if a, b := strings.Index(text, "{"), strings.LastIndex(text, "}"); a >= 0 && b > a {
	if err := json.Unmarshal([]byte(text[a:b+1]), &reply); err != nil {
		panic(err)
	}
}
fmt.Println(reply["verdict"], "-", reply["headline"])
areas, _ := reply["areas"].([]any)
for _, e := range areas {
	s, _ := e.(map[string]any)
	fmt.Println("area", s["area"], s["status"])
}
findings, _ := reply["findings"].([]any)
for _, e := range findings {
	f, _ := e.(map[string]any)
	edits, _ := f["edits"].([]any)
	fmt.Println(f["id"], f["file"], f["line"], f["severity"], len(edits), "edit(s)")
}
answers, _ := reply["flag_answers"].([]any)
for _, e := range answers {
	a, _ := e.(map[string]any)
	fmt.Println("answer", a["flag"], a["status"])
}

byte[] digest = MessageDigest.getInstance("SHA-256").digest(JSON.writeValueAsBytes(input));
String key = "goconc-desk:audit:" + HexFormat.of().formatHex(digest, 0, 8) + ":a1";

String jobId = api("POST", "/run", input, Map.of("Idempotency-Key", key)).path("job_id").asText();

JsonNode job;
long deadline = System.currentTimeMillis() + 180_000;   // 1 s interval, 180 s client-side limit
while (true) {
  job = api("GET", "/jobs/" + URLEncoder.encode(jobId, StandardCharsets.UTF_8), null, null);
  String s = job.path("status").asText();
  if (s.equals("succeeded") || s.equals("failed")) break;
  if (System.currentTimeMillis() > deadline) throw new RuntimeException("job timed out");
  Thread.sleep(1000);
}
if (job.path("status").asText().equals("failed")) throw new RuntimeException("run failed: " + job.path("error"));

System.out.println("truncated: " + job.path("truncated").asBoolean(false) + ", charged: " + job.path("charged_credits"));
String text = job.path("output").path("output").asText("");
JsonNode reply = JSON.readTree(text.substring(text.indexOf('{'), text.lastIndexOf('}') + 1));
System.out.println(reply.path("verdict").asText() + " - " + reply.path("headline").asText());
for (JsonNode s : reply.path("areas")) {
  System.out.println("area " + s.path("area").asText() + " " + s.path("status").asText());
}
for (JsonNode f : reply.path("findings")) {
  System.out.println(f.path("id").asText() + " " + f.path("file").asText() + " " + f.path("line") + " "
      + f.path("severity").asText() + " " + f.path("edits").size() + " edit(s)");
}
for (JsonNode a : reply.path("flag_answers")) {
  System.out.println("answer " + a.path("flag").asText() + " " + a.path("status").asText());
}

key = "goconc-desk:audit:#{Digest::SHA256.hexdigest(JSON.generate(input))[0, 16]}:a1"

job_id = api("POST", "/run", input, { "Idempotency-Key" => key })["job_id"]

deadline = Time.now + 180                       # 1 s interval, 180 s client-side limit
job = nil
loop do
  job = api("GET", "/jobs/#{URI.encode_www_form_component(job_id)}")
  break if %w[succeeded failed].include?(job["status"])
  raise "job timed out" if Time.now > deadline
  sleep 1
end
raise "run failed: #{job["error"].inspect}" if job["status"] == "failed"

puts "truncated: #{job["truncated"] == true}, charged: #{job["charged_credits"]}"
text = (job["output"] || {})["output"].to_s
reply = JSON.parse(text[text.index("{")..text.rindex("}")])
puts "#{reply["verdict"]} - #{reply["headline"]}"
(reply["areas"] || []).each { |s| puts "area #{s["area"]} #{s["status"]}" }
(reply["findings"] || []).each { |f| puts "#{f["id"]} #{f["file"]} #{f["line"].inspect} #{f["severity"]} #{(f["edits"] || []).size} edit(s)" }
(reply["flag_answers"] || []).each { |a| puts "answer #{a["flag"]} #{a["status"]}" }

$key = "goconc-desk:audit:" . substr(hash("sha256", json_encode($input)), 0, 16) . ":a1";

$jobId = api("POST", "/run", $input, ["Idempotency-Key" => $key])->job_id;

$deadline = time() + 180;                       // 1 s interval, 180 s client-side limit
while (true) {
    $job = api("GET", "/jobs/" . rawurlencode($jobId));
    if (in_array($job->status, ["succeeded", "failed"], true)) break;
    if (time() > $deadline) throw new RuntimeException("job timed out");
    sleep(1);
}
if ($job->status === "failed") throw new RuntimeException("run failed: " . json_encode($job->error ?? null));

echo "truncated: ", json_encode(($job->truncated ?? false) === true), ", charged: ", $job->charged_credits ?? "-", "\n";
$text = $job->output->output ?? "";
$reply = json_decode(substr($text, strpos($text, "{"), strrpos($text, "}") - strpos($text, "{") + 1));
echo $reply->verdict, " - ", $reply->headline, "\n";
foreach ($reply->areas ?? [] as $s) echo "area ", $s->area, " ", $s->status, "\n";
foreach ($reply->findings ?? [] as $f) echo $f->id, " ", $f->file, " ", json_encode($f->line ?? null), " ", $f->severity, " ", count($f->edits ?? []), " edit(s)\n";
foreach ($reply->flag_answers ?? [] as $a) echo "answer ", $a->flag, " ", $a->status, "\n";

var digest = System.Security.Cryptography.SHA256.HashData(Encoding.UTF8.GetBytes(JsonSerializer.Serialize(input)));
var key = "goconc-desk:audit:" + Convert.ToHexString(digest, 0, 8).ToLowerInvariant() + ":a1";

var started = await Api.Call("POST", "/run", input, new Dictionary<string, string> { ["Idempotency-Key"] = key });
var jobId = started!["job_id"]!.GetValue<string>();

JsonNode job;
var deadline = DateTime.UtcNow.AddSeconds(180);   // 1 s interval, 180 s client-side limit
while (true)
{
    job = (await Api.Call("GET", "/jobs/" + Uri.EscapeDataString(jobId)))!;
    var s = job["status"]?.GetValue<string>();
    if (s == "succeeded" || s == "failed") break;
    if (DateTime.UtcNow > deadline) throw new TimeoutException("job timed out");
    await Task.Delay(1000);
}
if (job["status"]?.GetValue<string>() == "failed") throw new Exception($"run failed: {job["error"]?.ToJsonString()}");

var truncated = job["truncated"] is JsonValue t && t.TryGetValue(out bool tb) && tb;
Console.WriteLine($"truncated: {truncated}, charged: {job["charged_credits"]}");
var text = job["output"]?["output"]?.GetValue<string>() ?? "";
var reply = JsonNode.Parse(text[text.IndexOf('{')..(text.LastIndexOf('}') + 1)])!;
Console.WriteLine($"{reply["verdict"]} - {reply["headline"]}");
foreach (var s in reply["areas"]?.AsArray() ?? new JsonArray())
    Console.WriteLine($"area {s?["area"]} {s?["status"]}");
foreach (var f in reply["findings"]?.AsArray() ?? new JsonArray())
    Console.WriteLine($"{f?["id"]} {f?["file"]} {f?["line"]?.ToJsonString() ?? "null"} {f?["severity"]} {f?["edits"]?.AsArray().Count ?? 0} edit(s)");
foreach (var a in reply["flag_answers"]?.AsArray() ?? new JsonArray())
    Console.WriteLine($"answer {a?["flag"]} {a?["status"]}");

Step 6 — POST /run-stream (Server-Sent Events, fix)

The alternative to step 5, and what the page uses: same kind of body, same Idempotency-Key header, one request. Run one or the other for a given input, not both. To show the second lane, the samples build the fix input of the pipeline example (with its own key) and stream it; to stream the audit input instead, pass the step 4 input and key. The response is text/event-stream. sdk.js splits it into frames on a blank line, takes the event name from an event: line (default message) and concatenates the data: lines, skips frames with no data or with data that is not JSON, and handles these events:

If the response is not text/event-stream, it is an ordinary JSON envelope: the SDK returns its data (an idempotent replay returns this way) or raises the error on a non-2xx status. Handle both shapes.

From the final payload the page reads output.output (falling back to the concatenated delta text), truncated and charged_credits. Browsers receive progress ticks rather than deltas from this endpoint, so the page relies on the final payload; if the stream fails part-way, it tries to recover a partial reply from whatever delta text arrived. The samples print the verdict and headline, each returned file’s path and size, each change (function, flags and change), each verification step, each open item and each question. To put the files into the paste and re-check them the way the page’s “Put every file into the paste” does, keep the reply text and run recheck.js with the lane fix. To fix code you audited, read handoff.js’s output instead of pipeline-check.json: makeInput then carries its audit_handoff.

# the fix worked example: pipeline-check.json from build-check.js
# (for audited code, read handoff.js's output instead; the + (...) adds its audit_handoff)
FBODY=$(jq -c --arg note "Parse hangs in production and sometimes panics with 'close of closed channel'; Lookup leaks goroutines when the partner API is slow. Fix those two, no new dependencies. Leave Drain exactly as it is for now - the status team owns it and is rewriting it next sprint." \
  '{task: "fix", code, facts: (.facts | tojson), note: $note} + (if .audit_handoff then {audit_handoff} else {} end)' \
  pipeline-check.json)
FKEY="goconc-desk:fix:$(printf '%s' "$FBODY" | shasum -a 256 | cut -c1-16):a1"

# -N turns off buffering; the whole stream lands in $STREAM
STREAM=$(api POST /run-stream -N -H "Idempotency-Key: $FKEY" -d "$FBODY")

# frames look like:
#   event: job
#   data: {...}
#
#   event: done
#   data: {"job_id":"...","status":"...","charged_credits":...,"output":{"output":"{\"task\":\"fix\",...}"}}

# the final reply text, from the done (or pending) frame:
REPLY=$(printf '%s\n' "$STREAM" \
  | awk '/^event:/{ev=$2} /^data:/ && (ev=="done" || ev=="pending"){sub(/^data: */,""); print}' \
  | jq -r '.output.output')
# an idempotent replay answers with a plain JSON envelope instead: REPLY=$(printf '%s' "$STREAM" | jq -r '.data.output.output')
printf '%s' "$REPLY" | jq '{verdict, headline,
  files: [(.files // [])[] | {path, characters: (.content | length)}],
  changes: [(.changes // [])[] | {function, flags, change}], verify, open, questions}'

# the fix worked example: pipeline-check.json from build-check.js
# (for audited code, pass handoff.js's output instead: make_input adds its audit_handoff)
fix_inp = make_input("fix", "pipeline-check.json",
                     "Parse hangs in production and sometimes panics with 'close of closed channel'; Lookup leaks goroutines when the partner API is slow. Fix those two, no new dependencies. Leave Drain exactly as it is for now - the status team owns it and is rewriting it next sprint.")
fix_key = "goconc-desk:fix:" + hashlib.sha256(json.dumps(fix_inp).encode()).hexdigest()[:16] + ":a1"

h = {"Content-Type": "application/json", "Authorization": "Bearer " + TOKEN, "Idempotency-Key": fix_key}
done, failure, streamed = None, None, ""
with requests.post(BASE + "/run-stream", headers=h, data=json.dumps(fix_inp), stream=True) as r:
    if "text/event-stream" not in r.headers.get("content-type", ""):
        try:
            env = r.json()
        except ValueError:
            env = {}
        if not r.ok:
            err = env.get("error") or {}
            raise ApiError(r.status_code, err.get("code"), err.get("message") or r.reason)
        done = env.get("data")
    else:
        event, data = "message", ""
        for line in r.iter_lines(decode_unicode=True):
            if line == "":                          # a blank line ends a frame
                if data:
                    try:
                        payload = json.loads(data)
                    except ValueError:
                        payload = None
                    if event == "delta" and payload is not None:
                        streamed += payload.get("text") or ""
                    elif event == "job":
                        print("job", payload)
                    elif event in ("done", "pending"):
                        done = payload
                    elif event == "error":
                        failure = payload
                event, data = "message", ""
            elif line.startswith("event:"):
                event = line[6:].strip()
            elif line.startswith("data:"):
                data += line[5:].strip()

if failure:
    raise SystemExit(f"{failure.get('code')}: {failure.get('message')} (job {failure.get('job_id')})")
done = done or {}
full = (done.get("output") or {}).get("output") or streamed
print("truncated:", done.get("truncated") is True, "charged:", done.get("charged_credits"))
result = json.loads(full[full.index("{"): full.rindex("}") + 1])
print(result["verdict"], "-", result["headline"])
for f in result.get("files", []):
    print("file", f["path"], len(f.get("content") or ""), "characters")
for c in result.get("changes", []):
    print("change", c.get("function"), ",".join(c.get("flags") or []) or "-", "-", c.get("change"))
for step in result.get("verify", []):
    print("verify", step)
for o in result.get("open", []):
    print("open", o["item"], "-", o.get("reason"))
for q in result.get("questions", []):
    print("question", q)

// the fix worked example: pipeline-check.json from build-check.js
// (for audited code, pass handoff.js's output instead: makeInput adds its audit_handoff)
const fixInput = makeInput("fix", "pipeline-check.json",
  "Parse hangs in production and sometimes panics with 'close of closed channel'; Lookup leaks goroutines when the partner API is slow. Fix those two, no new dependencies. Leave Drain exactly as it is for now - the status team owns it and is rewriting it next sprint.");
const fixKey = "goconc-desk:fix:" +
  createHash("sha256").update(JSON.stringify(fixInput)).digest("hex").slice(0, 16) + ":a1";

const res = await fetch(BASE + "/run-stream", {
  method: "POST",
  headers: { "Content-Type": "application/json", Authorization: "Bearer " + TOKEN, "Idempotency-Key": fixKey },
  body: JSON.stringify(fixInput),
});

let done = null, failure = null, streamed = "";
if (!(res.headers.get("content-type") || "").includes("text/event-stream")) {
  const json = await res.json().catch(() => ({}));
  if (!res.ok) throw new Error((json.error && json.error.message) || res.statusText);
  done = json.data;
} else {
  const reader = res.body.getReader();
  const decoder = new TextDecoder();
  let buffer = "";
  for (;;) {
    const chunk = await reader.read();
    if (chunk.done) break;
    buffer += decoder.decode(chunk.value, { stream: true });
    let idx;
    while ((idx = buffer.indexOf("\n\n")) >= 0) {
      const frame = buffer.slice(0, idx);
      buffer = buffer.slice(idx + 2);
      let event = "message", dataStr = "";
      for (const line of frame.split("\n")) {
        if (line.startsWith("event:")) event = line.slice(6).trim();
        else if (line.startsWith("data:")) dataStr += line.slice(5).trim();
      }
      if (!dataStr) continue;
      let data;
      try { data = JSON.parse(dataStr); } catch { continue; }
      if (event === "delta") streamed += data.text || "";
      else if (event === "job") console.log("job", data);
      else if (event === "done" || event === "pending") done = data;
      else if (event === "error") failure = data;
    }
  }
}
if (failure) throw new Error(`${failure.code}: ${failure.message} (job ${failure.job_id})`);

const full = (done && done.output && done.output.output) || streamed;
console.log("truncated:", !!(done && done.truncated), "charged:", done && done.charged_credits);
const result = JSON.parse(full.slice(full.indexOf("{"), full.lastIndexOf("}") + 1));
console.log(result.verdict, "-", result.headline);
for (const f of result.files || []) console.log("file", f.path, (f.content || "").length, "characters");
for (const c of result.changes || []) console.log("change", c.function, (c.flags || []).join(",") || "-", "-", c.change);
for (const step of result.verify || []) console.log("verify", step);
for (const o of result.open || []) console.log("open", o.item, "-", o.reason);
for (const q of result.questions || []) console.log("question", q);

// the fix worked example: pipeline-check.json from build-check.js
// (for audited code, pass handoff.js's output instead: makeInput adds its audit_handoff)
fixInput := makeInput("fix", "pipeline-check.json",
	"Parse hangs in production and sometimes panics with 'close of closed channel'; Lookup leaks goroutines when the partner API is slow. Fix those two, no new dependencies. Leave Drain exactly as it is for now - the status team owns it and is rewriting it next sprint.")
fixJSON, _ := json.Marshal(fixInput)
fixSum := sha256.Sum256(fixJSON)
fixKey := "goconc-desk:fix:" + hex.EncodeToString(fixSum[:8]) + ":a1"

sreq, err := newRequest("POST", "/run-stream", fixInput, map[string]string{"Idempotency-Key": fixKey})
if err != nil {
	panic(err)
}
sres, err := http.DefaultClient.Do(sreq)
if err != nil {
	panic(err)
}
defer sres.Body.Close()

var done, failure map[string]any
var streamed strings.Builder
if !strings.Contains(sres.Header.Get("Content-Type"), "text/event-stream") {
	var env envelope
	_ = json.NewDecoder(sres.Body).Decode(&env)
	if sres.StatusCode < 200 || sres.StatusCode > 299 {
		panic(errorFrom(sres, env))
	}
	_ = json.Unmarshal(env.Data, &done)
} else {
	sc := bufio.NewScanner(sres.Body)
	sc.Buffer(make([]byte, 64*1024), 16*1024*1024) // the done frame can be long
	event, data := "message", ""
	for sc.Scan() {
		line := sc.Text()
		switch {
		case line == "": // a blank line ends a frame
			if data != "" {
				var p map[string]any
				if json.Unmarshal([]byte(data), &p) == nil {
					switch event {
					case "delta":
						if t, ok := p["text"].(string); ok {
							streamed.WriteString(t)
						}
					case "job":
						fmt.Println("job", p)
					case "done", "pending":
						done = p
					case "error":
						failure = p
					}
				}
			}
			event, data = "message", ""
		case strings.HasPrefix(line, "event:"):
			event = strings.TrimSpace(line[6:])
		case strings.HasPrefix(line, "data:"):
			data += strings.TrimSpace(line[5:])
		}
	}
}
if failure != nil {
	panic(fmt.Sprintf("%v: %v (job %v)", failure["code"], failure["message"], failure["job_id"]))
}

full := streamed.String()
if out, ok := done["output"].(map[string]any); ok {
	if s, ok := out["output"].(string); ok && s != "" {
		full = s
	}
}
fmt.Println("truncated:", done["truncated"] == true, "charged:", done["charged_credits"])
var result map[string]any
if a, b := strings.Index(full, "{"), strings.LastIndex(full, "}"); a >= 0 && b > a {
	if err := json.Unmarshal([]byte(full[a:b+1]), &result); err != nil {
		panic(err)
	}
}
fmt.Println(result["verdict"], "-", result["headline"])
files, _ := result["files"].([]any)
for _, e := range files {
	f, _ := e.(map[string]any)
	c, _ := f["content"].(string)
	fmt.Println("file", f["path"], len([]rune(c)), "characters")
}
changes, _ := result["changes"].([]any)
for _, e := range changes {
	c, _ := e.(map[string]any)
	var flags []string
	if fs, ok := c["flags"].([]any); ok {
		for _, fl := range fs {
			flags = append(flags, fmt.Sprint(fl))
		}
	}
	fl := strings.Join(flags, ",")
	if fl == "" {
		fl = "-"
	}
	fmt.Println("change", c["function"], fl, "-", c["change"])
}
verify, _ := result["verify"].([]any)
for _, st := range verify {
	fmt.Println("verify", st)
}
open, _ := result["open"].([]any)
for _, e := range open {
	o, _ := e.(map[string]any)
	fmt.Println("open", o["item"], "-", o["reason"])
}
questions, _ := result["questions"].([]any)
for _, q := range questions {
	fmt.Println("question", q)
}

// the fix worked example: pipeline-check.json from build-check.js
// (for audited code, pass handoff.js's output instead: makeInput adds its audit_handoff)
Map<String, Object> fixInput = makeInput("fix", "pipeline-check.json",
    "Parse hangs in production and sometimes panics with 'close of closed channel'; Lookup leaks goroutines when the partner API is slow. Fix those two, no new dependencies. Leave Drain exactly as it is for now - the status team owns it and is rewriting it next sprint.");
byte[] fixDigest = MessageDigest.getInstance("SHA-256").digest(JSON.writeValueAsBytes(fixInput));
String fixKey = "goconc-desk:fix:" + HexFormat.of().formatHex(fixDigest, 0, 8) + ":a1";

HttpRequest sreq = request("POST", "/run-stream", fixInput, Map.of("Idempotency-Key", fixKey)).build();
HttpResponse<Stream<String>> sres = HTTP.send(sreq, HttpResponse.BodyHandlers.ofLines());

JsonNode done = null, failure = null;
StringBuilder streamed = new StringBuilder();
if (!sres.headers().firstValue("content-type").orElse("").contains("text/event-stream")) {
  JsonNode env = JSON.readTree(sres.body().collect(Collectors.joining("\n")));
  if (env == null) env = JSON.createObjectNode();
  if (sres.statusCode() / 100 != 2) throw errorFrom(sres.statusCode(), env);
  done = env.path("data");
} else {
  String event = "message";
  StringBuilder data = new StringBuilder();
  Iterator<String> it = sres.body().iterator();
  while (it.hasNext()) {
    String line = it.next();
    if (line.isEmpty()) {                        // a blank line ends a frame
      if (data.length() > 0) {
        JsonNode p = null;
        try { p = JSON.readTree(data.toString()); } catch (Exception ignored) { }
        if (p != null) {
          switch (event) {
            case "delta": streamed.append(p.path("text").asText("")); break;
            case "job": System.out.println("job " + p); break;
            case "done": case "pending": done = p; break;
            case "error": failure = p; break;
            default: break;
          }
        }
      }
      event = "message";
      data.setLength(0);
    } else if (line.startsWith("event:")) event = line.substring(6).trim();
    else if (line.startsWith("data:")) data.append(line.substring(5).trim());
  }
}
if (failure != null) {
  throw new RuntimeException(failure.path("code").asText() + ": " + failure.path("message").asText()
      + " (job " + failure.path("job_id").asText() + ")");
}

String full = done == null ? "" : done.path("output").path("output").asText("");
if (full.isEmpty()) full = streamed.toString();
System.out.println("truncated: " + (done != null && done.path("truncated").asBoolean(false))
    + ", charged: " + (done == null ? "-" : done.path("charged_credits").toString()));
JsonNode result = JSON.readTree(full.substring(full.indexOf('{'), full.lastIndexOf('}') + 1));
System.out.println(result.path("verdict").asText() + " - " + result.path("headline").asText());
for (JsonNode f : result.path("files")) {
  System.out.println("file " + f.path("path").asText() + " " + f.path("content").asText("").codePointCount(0, f.path("content").asText("").length()) + " characters");
}
for (JsonNode c : result.path("changes")) {
  List<String> flags = new ArrayList<>();
  c.path("flags").forEach(fl -> flags.add(fl.asText()));
  System.out.println("change " + c.path("function").asText() + " " + (flags.isEmpty() ? "-" : String.join(",", flags))
      + " - " + c.path("change").asText());
}
for (JsonNode step : result.path("verify")) System.out.println("verify " + step.asText());
for (JsonNode o : result.path("open")) System.out.println("open " + o.path("item").asText() + " - " + o.path("reason").asText());
for (JsonNode q : result.path("questions")) System.out.println("question " + q.asText());

# the fix worked example: pipeline-check.json from build-check.js
# (for audited code, pass handoff.js's output instead: make_input adds its audit_handoff)
fix_input = make_input("fix", "pipeline-check.json",
                       "Parse hangs in production and sometimes panics with 'close of closed channel'; Lookup leaks goroutines when the partner API is slow. Fix those two, no new dependencies. Leave Drain exactly as it is for now - the status team owns it and is rewriting it next sprint.")
fix_key = "goconc-desk:fix:#{Digest::SHA256.hexdigest(JSON.generate(fix_input))[0, 16]}:a1"

uri, req = build_request("POST", "/run-stream", fix_input, { "Idempotency-Key" => fix_key })
done = failure = nil
streamed = +""

Net::HTTP.start(uri.host, uri.port, use_ssl: true, read_timeout: 300) do |http|
  http.request(req) do |res|
    unless res["content-type"].to_s.include?("text/event-stream")
      env = (JSON.parse(res.body) rescue {})
      unless res.is_a?(Net::HTTPSuccess)
        raise ApiError.new(res.code.to_i, env.dig("error", "code"), env.dig("error", "message") || res.message)
      end
      done = env["data"]
      next
    end
    buf = +""
    res.read_body do |chunk|
      buf << chunk
      while (i = buf.index("\n\n"))
        frame = buf.slice!(0, i + 2)
        event = "message"
        data = +""
        frame.split("\n").each do |line|
          if line.start_with?("event:") then event = line[6..].strip
          elsif line.start_with?("data:") then data << line[5..].strip
          end
        end
        next if data.empty?
        payload = (JSON.parse(data) rescue nil)
        next if payload.nil?
        case event
        when "delta" then streamed << payload["text"].to_s
        when "job" then puts "job #{payload.inspect}"
        when "done", "pending" then done = payload
        when "error" then failure = payload
        end
      end
    end
  end
end

raise "#{failure["code"]}: #{failure["message"]} (job #{failure["job_id"]})" if failure
done ||= {}
full = (done["output"] || {})["output"].to_s
full = streamed if full.empty?
puts "truncated: #{done["truncated"] == true}, charged: #{done["charged_credits"]}"
result = JSON.parse(full[full.index("{")..full.rindex("}")])
puts "#{result["verdict"]} - #{result["headline"]}"
(result["files"] || []).each { |f| puts "file #{f["path"]} #{f["content"].to_s.length} characters" }
(result["changes"] || []).each do |c|
  flags = (c["flags"] || []).join(",")
  puts "change #{c["function"]} #{flags.empty? ? "-" : flags} - #{c["change"]}"
end
(result["verify"] || []).each { |step| puts "verify #{step}" }
(result["open"] || []).each { |o| puts "open #{o["item"]} - #{o["reason"]}" }
(result["questions"] || []).each { |q| puts "question #{q}" }

// the fix worked example: pipeline-check.json from build-check.js
// (for audited code, pass handoff.js's output instead: make_input adds its audit_handoff)
$fixInput = make_input("fix", "pipeline-check.json",
    "Parse hangs in production and sometimes panics with 'close of closed channel'; Lookup leaks goroutines when the partner API is slow. Fix those two, no new dependencies. Leave Drain exactly as it is for now - the status team owns it and is rewriting it next sprint.");
$fixKey = "goconc-desk:fix:" . substr(hash("sha256", json_encode($fixInput)), 0, 16) . ":a1";

$done = null; $failure = null; $streamed = ""; $buf = ""; $ctype = "";

$handle = function (string $event, string $data) use (&$done, &$failure, &$streamed) {
    $p = json_decode($data);
    if ($p === null) return;                    // not JSON: skipped, as sdk.js does
    switch ($event) {
        case "delta": $streamed .= $p->text ?? ""; break;
        case "job": echo "job ", json_encode($p), "\n"; break;
        case "done": case "pending": $done = $p; break;
        case "error": $failure = $p; break;
    }
};

$ch = curl_init(BASE . "/run-stream");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => headers_for(["Idempotency-Key" => $fixKey]),
    CURLOPT_POSTFIELDS => json_encode($fixInput, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE),
    CURLOPT_HEADERFUNCTION => function ($ch, $line) use (&$ctype) {
        if (stripos($line, "content-type:") === 0) $ctype = strtolower(trim(substr($line, 13)));
        return strlen($line);
    },
    CURLOPT_WRITEFUNCTION => function ($ch, $chunk) use (&$buf, &$ctype, $handle) {
        $buf .= $chunk;                         // collects the response in memory
        if (strpos($ctype, "text/event-stream") === false) return strlen($chunk); // plain JSON: parse at the end
        while (($i = strpos($buf, "\n\n")) !== false) {
            $frame = substr($buf, 0, $i);
            $buf = substr($buf, $i + 2);
            $event = "message"; $data = "";
            foreach (explode("\n", $frame) as $line) {
                if (strpos($line, "event:") === 0) $event = trim(substr($line, 6));
                elseif (strpos($line, "data:") === 0) $data .= trim(substr($line, 5));
            }
            if ($data !== "") $handle($event, $data);
        }
        return strlen($chunk);
    },
]);
if (curl_exec($ch) === false) throw new RuntimeException(curl_error($ch));
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
curl_close($ch);

if (strpos($ctype, "text/event-stream") === false) {
    $env = json_decode($buf) ?? new stdClass();
    if ($status < 200 || $status > 299) {
        throw new ApiError($status, $env->error->code ?? null, $env->error->message ?? "HTTP $status");
    }
    $done = $env->data ?? null;
}
if ($failure) throw new RuntimeException(($failure->code ?? "") . ": " . ($failure->message ?? "") . " (job " . ($failure->job_id ?? "") . ")");

$full = $done->output->output ?? "";
if ($full === "") $full = $streamed;
echo "truncated: ", json_encode(($done->truncated ?? false) === true), ", charged: ", $done->charged_credits ?? "-", "\n";
$result = json_decode(substr($full, strpos($full, "{"), strrpos($full, "}") - strpos($full, "{") + 1));
echo $result->verdict, " - ", $result->headline, "\n";
foreach ($result->files ?? [] as $f) echo "file ", $f->path, " ", mb_strlen($f->content ?? ""), " characters\n";
foreach ($result->changes ?? [] as $c) {
    $flags = implode(",", $c->flags ?? []);
    echo "change ", $c->function ?? "", " ", $flags === "" ? "-" : $flags, " - ", $c->change ?? "", "\n";
}
foreach ($result->verify ?? [] as $step) echo "verify ", $step, "\n";
foreach ($result->open ?? [] as $o) echo "open ", $o->item, " - ", $o->reason ?? "", "\n";
foreach ($result->questions ?? [] as $q) echo "question ", $q, "\n";

// the fix worked example: pipeline-check.json from build-check.js
// (for audited code, pass handoff.js's output instead: MakeInput adds its audit_handoff)
var fixInput = MakeInput("fix", "pipeline-check.json",
    "Parse hangs in production and sometimes panics with 'close of closed channel'; Lookup leaks goroutines when the partner API is slow. Fix those two, no new dependencies. Leave Drain exactly as it is for now - the status team owns it and is rewriting it next sprint.");
var fixDigest = System.Security.Cryptography.SHA256.HashData(Encoding.UTF8.GetBytes(JsonSerializer.Serialize(fixInput)));
var fixKey = "goconc-desk:fix:" + Convert.ToHexString(fixDigest, 0, 8).ToLowerInvariant() + ":a1";

using var sreq = Api.Request("POST", "/run-stream", fixInput, new Dictionary<string, string> { ["Idempotency-Key"] = fixKey });
using var sres = await Api.Http.SendAsync(sreq, HttpCompletionOption.ResponseHeadersRead);

JsonNode? done = null, failure = null;
var streamed = new StringBuilder();
if (sres.Content.Headers.ContentType?.MediaType != "text/event-stream")
{
    JsonNode? env = null;
    try { env = JsonNode.Parse(await sres.Content.ReadAsStringAsync()); } catch (JsonException) { }
    if (!sres.IsSuccessStatusCode) throw Api.ErrorFrom(sres, env);
    done = env?["data"];
}
else
{
    using var reader = new StreamReader(await sres.Content.ReadAsStreamAsync());
    var ev = "message";
    var data = new StringBuilder();
    string? line;
    while ((line = await reader.ReadLineAsync()) != null)
    {
        if (line.Length == 0)                    // a blank line ends a frame
        {
            if (data.Length > 0)
            {
                JsonNode? p = null;
                try { p = JsonNode.Parse(data.ToString()); } catch (JsonException) { }
                if (p != null)
                {
                    switch (ev)
                    {
                        case "delta": streamed.Append(p["text"]?.GetValue<string>() ?? ""); break;
                        case "job": Console.WriteLine($"job {p.ToJsonString()}"); break;
                        case "done": case "pending": done = p; break;
                        case "error": failure = p; break;
                    }
                }
            }
            ev = "message";
            data.Clear();
        }
        else if (line.StartsWith("event:")) ev = line[6..].Trim();
        else if (line.StartsWith("data:")) data.Append(line[5..].Trim());
    }
}
if (failure != null) throw new Exception($"{failure["code"]}: {failure["message"]} (job {failure["job_id"]})");

var full = done?["output"]?["output"]?.GetValue<string>();
if (string.IsNullOrEmpty(full)) full = streamed.ToString();
var cut = done?["truncated"] is JsonValue tv && tv.TryGetValue(out bool cutShort) && cutShort;
Console.WriteLine($"truncated: {cut}, charged: {done?["charged_credits"]}");
var result = JsonNode.Parse(full[full.IndexOf('{')..(full.LastIndexOf('}') + 1)])!;
Console.WriteLine($"{result["verdict"]} - {result["headline"]}");
foreach (var f in result["files"]?.AsArray() ?? new JsonArray())
    Console.WriteLine($"file {f?["path"]} {(f?["content"]?.GetValue<string>() ?? "").Length} characters");
foreach (var c in result["changes"]?.AsArray() ?? new JsonArray())
{
    var flags = string.Join(",", (c?["flags"]?.AsArray() ?? new JsonArray()).Select(fl => fl?.GetValue<string>()));
    Console.WriteLine($"change {c?["function"]} {(flags == "" ? "-" : flags)} - {c?["change"]}");
}
foreach (var step in result["verify"]?.AsArray() ?? new JsonArray()) Console.WriteLine($"verify {step}");
foreach (var o in result["open"]?.AsArray() ?? new JsonArray()) Console.WriteLine($"open {o?["item"]} - {o?["reason"]}");
foreach (var q in result["questions"]?.AsArray() ?? new JsonArray()) Console.WriteLine($"question {q}");

What the page does that you now do

• Reads the paste in the browser and builds code and facts from it (gokit.js), joining dropped files under // file: lines and cutting a large paste on whole files with a // [goconc-desk: not sent: ...] line; you send the same two strings.
• Prices every input with /estimate and refuses to run below min_credits, or on a paste with no Go it can read.
• Sends each attempt with an input- and lane-derived Idempotency-Key, and retries once with retry_note when a reply does not parse.
• Closes a cut-off JSON reply and shows what arrived when truncated is true or the stream ends early.
• Hands an audit to the fix lane as audit_handoff, with every edit applied to the paste first, and only while that edited paste is unchanged.
• Checks the reply against the code (recon.js), in the browser: files, lines, evidence, every edit applied in order and the free check re-run after each finding, flag answers and verdict; the fixed files put back, re-checked and matched against the changes list and the open items; and repeated credentials. recheck.js above runs the same checks for you.

Or skip all of this and use GoConc Desk in the browser: the check, the flags, the goroutine, channel, lock and context inventories, putting an edit or the fixed files back into the paste, and the Markdown and CSV exports are free.