- ForgeActionFailure gains `unknown` for an answer that does not confirm
the outcome; the GitHub provider passes it on instead of `failed`, the
panel Remote refuses with `forgePanel/action-unknown`, a viewed mark
stays, and the other actions ask the reader to check the browser.
- Reruns skip workflow runs with a pending check, try every finished run,
and report the refused ones together; the card offers a rerun only when
a failed check's run has finished.
- Review requests resolve users and teams to node ids and call
`requestReviews`, which GitHub Enterprise Server 3.19 and 3.20 have;
bots still go through `requestReviewsByLogin`.
- Viewed marks are kept per change request and head, so a reread at the
same head keeps writes in flight and their locks, and paths named after
object properties read only their own entries.
- The reviewer search never chooses from the listing of an earlier query.
- Documentation states the unknown code, the branch update evidence, and
the `canBeRebased` approximation, and drops stray blank lines.
The forge subsystem page gains the overview and viewed mark types and
contracts, and the generated Cordis, configuration, and event catalogs
follow the new service methods and the maxViewedFiles option.
A write to a thread or comment now reads, in the head check, the pull
request that holds it and is refused without a mutation when that is
another pull request. Submitting the pending review keeps the
submission to reconcile, so an unknown outcome blocks a second review.
GraphQL errors count as refusals only when every type names one, so a
GitHub timeout reports an unknown outcome. Pending reviews are found
by viewerDidAuthor among up to 100, without the unused commit field. A
resolved thread stays open while the reader writes in it, unsupported
writes no longer poll, and the docs state the partial two-step write.
- A jump to a thread centered its card on every later jump to the same file, since the jump target outlived the jump.
The scroll target now carries the card to center and is cleared when the jump ends; unfolding still follows the
latest thread jump.
- In a commit range view, a thread on a file the chosen commits do not change opened on the host instead of choosing
all commits; a thread the chosen commits do not hold now always chooses all commits first.
- A quote of an old-side thread named the head as the commit its lines number. It now says the lines number the file
before the change and names the head only as where the diff ends, and ForgeAnchor documents the same.
- Refresh reads review threads from the host past the panel's cache (`changeRequestReview` takes `fresh`), so a thread
resolved since shows without waiting for `reviewRefreshMs`; `maxCachedReviewBytes` defaults to 16 MiB, at least
one read under forge-github's default `maxOutputBytes`.
- Picking a thread from a list that covers the files moves the focus to the thread's card.
- `ForgeReviewData.viewer`, its GraphQL field, `ThreadActions.viewer`, and `ThreadReadState.unsupported` had no
consumer and are removed.
- A quoted outdated thread is named by the lines it was written on; a missing pull request or repository makes a
review read `not-found`; a truncated read that kept no thread still offers the thread list.
The forge subsystem page documents ctx.forge.writeReview, its write
and result types, and the panel's changeRequestReviewWrite; the package
READMEs describe the GitHub mutations and their measured behavior, the
thread actions, and the pending review flow. A new Agent Note records
moving pull request comment drafts to the code host's pending review,
and the forge panel note links it. The Web e2e replies to, edits,
deletes, and resolves threads, and starts, submits, and discards a
pending review through the scripted gh double.
Status snapshots carry the base commit the host recorded with the head
(baseSha). ForgeService.diff passes it to the provider when the latest
status names the requested head, and forge-github starts the compare read
from it while its GraphQL read confirms the head; a stale head or another
base cancels and joins the early read.
The forge subsystem page documents ctx.forge.readReview, its thread
types, and the panel's changeRequestReview cache; the package READMEs
describe the GitHub thread mapping, the overlay and thread list, and the
new panel Config fields. An upgrade guide covers the unsupported
ForgeFailure code. The Web e2e overlays scripted threads, opens them from
the thread list, and sends a quoted thread through a replayed turn.
- Shift-chosen commits must follow each other as first parents; the picker
says why it keeps a run that leaves the line, and the Host refuses one with
forgePanel/commits-not-linear for the Branch scope and change requests.
- The Branch scope lists its newest maxCommits commits with
--no-show-signature, so log.showSignature cannot corrupt the listing.
- Viewed marks merge with the stored entry on each write and follow the
storage event, so tabs of one Session keep each other's marks.
- .gitattributes patterns follow Git's wildmatch rules, checked against
git check-attr; change digests include file mode lines.
- GitHub commit pagination refuses a repeated cursor or a changed count;
commits validates the repository before its host like the other reads.
- The commit list is read once per head, base, or refresh; the lens menu
hides the count of the disabled Tests lens.
A repository's root .gitattributes now decides a file's review layer first:
dsh-review-layer names test, interface, or implementation, and
linguist-generated still places a file in the test layer. The testPaths and
interfacePaths settings add globs before the built-in rules and are empty by
default. The built-in rules follow the default conventions of common
languages and tools instead of treating every JSON or YAML file and every
name containing config as interface. This repository declares its own locale
dictionaries, snapshot tree, pairing records, and types modules.
- forge-github: repeat a compare read without --allow-escape-sequences when
a gh older than 2.97 rejects the option; such a gh prints escape sequences
unchanged, so every version reads every diff (checked with gh 2.96.0 and
2.100.0 on a pull request whose patch holds an ESC byte).
- client-ui-forge: a stale refusal now re-runs the read effect, so a status
that arrived during the read, including a failed poll that keeps the
earlier head, starts the next read at once instead of leaving the changes
view loading.
- forge: ctx.forge.diff polls at once only for the first stale read at a head
commit; later stale reads at it wait for the regular poll, which bounds the
read-poll loop while GitHub's answers briefly disagree.
- forge-github: review thread pages share the byte budget of a complete
check read.
- client-ui-forge: a truncated count shows its "+" even when it is zero.
- READMEs: document the batch deadline and rewritten-base limitations.
_Kerman