Skip to content

v0.7.0

Choose a tag to compare

@github-actions github-actions released this 01 Oct 15:59
· 72 commits to main since this release

The tool learning to hand work out the way the tracker actually allows. An
offer on a fresh issue cannot be an assignment, so offers now reserve the issue
with a label, settle assigns once the holder speaks, and stale finds the
holds nobody touched. Moves the middle digit: file-issue now refuses when
it cannot read the tracker, and release now unassigns, so two calls that
used to succeed one way now behave another.

Added

  • maintainer settle turns answered offers into assignments, and
    maintainer stale [days] names cold holds.
    GitHub drops an assignee who is
    not a collaborator and has not posted on the issue, so the 22 issues filed on
    sysknife on 2026-10-01 could be offered and not assigned. settle assigns each
    answered offer and reads it back. stale replaces the per-issue timeline read
    that found #440, #428 and #433 nine or more days cold (lesson 106).
  • maintainer offer applies the claim label, and takes --second. The
    label is the reservation other people see while the assignment is impossible.
    --second is the maintainer overriding the one-offer rule per call; on
    2026-10-01 the rule refused a requested batch and the offers went out as bare
    gh comments with no read-back (lesson 106).
  • maintainer file-issue --dry-run. A rehearsal had to be POST=off, a
    profile setting, and a "what does this do" call on sysknife filed #542 titled
    "x" (lesson 105).

Fixed

  • file-issue stops when it cannot read the tracker. _existing_finding
    returned None for a failed read, which is also the answer for "no
    duplicate", so a gh failure filed the finding twice.

  • release unassigns the person and removes the claim label. The comment
    alone left #440 assigned and labelled until both were removed by hand.

  • maintainer offer <issue> <user> <text> posts an offer on the issue's own
    thread, and only when nobody holds it.
    holders and offers read an
    issue's thread, and until now an offer was whatever prose the maintainer typed
    wherever they were typing it. On 2026-10-01 three sysknife offers lived only in
    pull-request reviews (#530 on #528, #474 on #514, #411 on #515), and two were
    offered again within hours: #474 to a second contributor while the first held
    it, and #411 five hours after its holder had accepted it on #411 itself.
    offer refuses an issue somebody holds, one an open pull request closes, one
    that is reserved, assigned or claimed, anyone who already holds an open offer,
    and text naming a second person. It refuses when the open pull requests cannot
    be read, and reads the comment back. offers and offer share one
    _offer_ledger, so the refusal and the printout cannot disagree. Seven tests,
    two of them pinned to their reason because they passed while the command did
    not exist yet (lesson 104).

  • A dependency bump may now be a base-image digest bump.
    classify_dependency_bump.py knew Cargo, npm and GitHub Actions, and answered
    Dockerfile is not dependency metadata for anything else. sysknife pins its
    build images by manifest-list digest so a moved tag cannot change the build,
    and Dependabot bumps them, so every such pull request had only two ways to
    land: an asserted receipt, which an unattended run may not write, or
    gh pr merge --admin, which is the path this gate exists to remove. The new
    dockerfile arm refuses a changed line that is not a FROM, a base image
    that stops being pinned by digest, and an added FROM naming an image no
    removed FROM named, which is the no-new-source claim one registry over.
    scripts/resolve_image_digest.py then asks the registry what the tag resolves
    to, over the Registry v2 token dance with no new binary dependency, and
    verify-deps refuses a digest that is not the answer. Nine tests. The four
    refusals assert their own reason, because while the classifier still refused
    every Dockerfile for being a Dockerfile, a bare "verdict": "refused" passed
    for a code path the test was not about (lesson 101).

  • The docs-coverage check matches whole command names. It searched the docs
    for each command as a substring, so maintainer offer read as documented
    because maintainer offers is. It now needs a word boundary, which found
    offer and nothing else.

  • A GitHub login is compared the way GitHub compares it: without case.
    sysknife#519 was offered to @TayfurYldz, the pull request that closed it
    came back from the API authored by tayfuryldz, and the gate refused to
    merge the offered person's own work because it compared the two strings
    exactly. They are one account, id 238304586. The same comparison ran about
    twenty times across the offer tracker, the gate and the identity checks, and
    one of them failed open: with MAINTAINER_ACCOUNT typed in any case other
    than the API's, every maintainer comment read as somebody else's, holders
    found nobody, and the gate let a merge through over a live offer. A release
    spelled in another case from its offer retracted nothing, and assign read
    its own successful assignment back as GitHub having dropped it. Mentions are
    canonicalised where they are parsed, every login read from the API goes
    through one _login(), and the five identity guards compare
    case-insensitively, which refuses exactly the accounts they refused before
    because no two GitHub accounts differ only in case. The refusal also printed
    its holder list with nothing after the last name, so it read
    TayfurYldzwas pointed at. Seven tests, each mutation-proved; two of them
    exist because the first five could not tell a lowercased source from a
    case-insensitive match (lesson 103).

  • A verifier that inspected nothing no longer looks like one with nothing to
    inspect.
    verify-deps read its action pins with
    while ... done < <(python3 -c ...), and process substitution reports the
    status of the redirection rather than of the command inside it. A producer
    that died left the loop reading an empty stream, the counter at zero, and a
    sealed receipt reading 0 action pin(s) verified about a diff that bumped a
    pin. Both loops now read from a variable, so a dead producer refuses, and each
    is followed by an equality against the count the classifier declared: zero
    checked out of one declared is a check that did not run, not a clean bump.
    Mutation-proved in both directions (lesson 102).

Two guards, both from the same session's work on sysknife, and both about a
check that answered a narrower question than the one being asked.

  • A mutation that lands only outside production code earns no receipt.
    cmd_verify asked whether the mutation changed a file, never which file. A
    suite's suite_mutate_glob lists file types, so sysknife's rust suite mutates
    *.rs, which is every test file as well as every source file. A mutation
    aimed at the contributor's own test passed every check and minted a receipt,
    having proved that a test notices its own edit. Observed twice on 2026-09-29
    in the reviewer's own work: an MCP boundary test that called the sanitiser
    directly rather than driving the route stayed green with the route's wiring
    deleted, and a full-view renderer test used only short lines so a reverted
    length cap changed nothing it asserted. apply_mutation now reports which
    paths it changed instead of how many, and cmd_verify refuses when the diff
    carries production code and the mutation reached none of it, printing what it
    did change. Only asked when the diff has production code at all, because a
    docs-only pull request has nothing to mutate and pick_suite already decides
    what its receipt may claim. Two tests: one mutation into a test file, refused,
    and one into the production file beside it, which still earns a receipt,
    because a guard that refuses everything is not a guard
    (lesson 99).

  • screen reports workflow exposure on every verdict, and reads the branch
    rather than the head.
    The warning against approving a queued workflow run
    fired only under DO NOT EXECUTE, and only on .github/workflows/ paths in
    the current diff. sysknife#527 arrived as one commit touching Cargo.lock
    over a branch force-pushed away from 441f163c, which had edited
    .github/workflows/ci.yml; its runs were still in the approval queue and the
    author meant to restore it. The timeline cannot answer this, because a
    head_ref_force_pushed event's commit_id is the commit the ref points at
    after the push and never names what was dropped. The workflow runs can: every
    push queues runs pinned to the head it pushed, so a head_sha on that branch
    that is not among the pull request's commits is a head that existed and no
    longer does. A docs-only change is INERT and its queued run is exactly as
    dangerous as anyone else's, so the judgement now prints on every verdict, and
    an unreadable history says so and says to treat the approval as unsafe rather
    than going quiet. Five tests, one of them a force-push over an innocent commit
    so the guard cannot pass by crying wolf (lesson 100).