Skip to content

feat(cli): receipt the absorbed update under the job token, and skip the queued run - #7456

Closed
waynesun09 wants to merge 2 commits into
steer-monitorfrom
steer-receipt
Closed

waynesun09 wants to merge 2 commits into
steer-monitorfrom
steer-receipt

Conversation

@waynesun09

@waynesun09 waynesun09 commented Sep 18, 2026 •

Copy link
Copy Markdown
Member

Implements the design recorded in #6957 (closed as completed; this stack ships it).

A run in flight absorbs an update to its work item, and the run queued behind it then does the
same work again — so steering currently costs more than preserving alone: two reviews of one
head where preserving alone produces one. This PR adds the record that closes that, and the check
that reads it.

After a successful run that absorbed at least one update, the runner posts a receipt naming the
follow-up runs it consumed. A queued run reads the latest receipt in its pre-flight — before the
start comment and before the pre-script, whose side effects are not free — and exits 0 without
starting the agent when it finds its own run id listed.

The receipt's author is the whole of the authentication, and it is the GitHub Actions job token's.
The runner captures that token before minting swaps in the role token, so nothing inside the
sandbox holds it. Two conditions are enforced in code rather than assumed:

  • Minting must actually have swapped the credential. With no mint URL or no role nothing is
    swapped, the same token stays in the environment a post-script inherits, and both the writer and
    the skip check turn off.
  • The receipt login and the role login must differ. The action's github_token is a
    caller-supplied input that can resolve to the identity the agent posts under; the check refuses
    to skip when they match, and warns.

No receipt is honoured while any definition in .fullsend/providers/ expands GH_WORKFLOW_TOKEN.
That hands the job token to a sandbox, where the agent can recover it (ADR 0114).

Scope and failure direction: one receipt per run rather than per steer, naming only what the
iteration whose output shipped absorbed, and only when that output was published — a run whose
agent reported an error has its post-script withheld and writes none, as do failed, cancelled,
skipped and unvalidated runs, and runs that absorbed nothing. Everything fails open: a false
"already handled" silently drops work, while a false "not handled" costs one run, which for review is a full review.

The terminal status comment keeps an informational copy of the marker so a reader can see what a
run absorbed. The skip check does not honour it, and agent-authored text is neutralized before it
reaches that comment, so no App-authored marker of any shape is a receipt.

A second skip covers review duplicates no receipt can. When the coder App opens a pull
request and labels it ready-for-review a second later, both events route a review. The run in
flight rejects the other as not fresh, absorbs nothing and writes no receipt, so both ran a full
review. A queued review now exits 0 when the review App reviewed the current head after the
queued run was created. It is matched on the App's exact logins and the forge's App verdict. Only
opened, reopened, synchronize, ready-for-review and label events can skip. A human /fs-review,
a manual re-run, an unreadable event and every error run the review. It works with steering on or
off.

The decision is recorded in ADR 0120. Steering stays off by default on this PR.

What to look at

  • steerReceiptToken — the two conditions above, and why reading the Actions API is deliberately
    not held to the same bar (those reads prove no authorship).
  • shouldPostSteerReceipt — the post-script gate. It is stricter than the terminal status
    comment on purpose: a receipt instructs another run to do nothing, so it has to mean the output
    was published.
  • steerAlreadyHandled — every path returns "not handled" on error.
  • headAlreadyReviewed and runPreflightSkips — the second skip, and the single call site that
    runs both before the start comment. A go/ast test pins that call.
  • GitLab is a no-op: its job token can neither post nor read notes, so there is no receipt and the
    queued pipeline does the work exactly as it does today.

@qodo-code-review

Copy link
Copy Markdown

PR Summary by Qodo

Authenticate steer receipts and skip absorbed queued runs

✨ Enhancement 🐞 Bug fix 🧪 Tests 📝 Documentation 🕐 40+ Minutes

Grey Divider

AI Description

• Post job-token-authenticated receipts after successful runs absorb queued updates.
• Skip queued GitHub Actions runs when the latest trusted receipt names them.
• Fail open and neutralize agent-authored markers to prevent forged work suppression.
Diagram

sequenceDiagram
    participant Running as In-flight Run
    participant Runtime as Agent Runtime
    participant Timeline as GitHub Timeline
    participant Queued as Queued Run
    participant Agent as New Agent
    Running->>Runtime: Deliver queued updates
    Runtime-->>Running: Acknowledge run IDs
    Running->>Timeline: Post job-token receipt
    Queued->>Timeline: Read latest receipt
    Timeline-->>Queued: Return marker and author
    Queued->>Queued: Validate identities and run ID
    alt Trusted receipt consumes run
        Queued-->>Queued: Exit successfully
    else Missing or untrusted receipt
        Queued->>Agent: Start normal run
    end
Loading
High-Level Assessment

The following are alternative approaches to this PR:

1. Always execute queued runs
  • ➕ Preserves the existing at-least-once behavior without a new trust boundary.
  • ➕ Cannot suppress work because of a forged or malformed receipt.
  • ➖ Repeats work already completed by the in-flight run.
  • ➖ Makes steering more expensive than preserving updates without steering.
2. Use terminal status markers
  • ➕ Avoids posting a separate receipt comment.
  • ➕ Reuses the existing completion notification lifecycle.
  • ➖ Status comments use the same App identity as agent-authored output.
  • ➖ Injected marker text or sandbox scripts could forge a skip signal.

Recommendation: Use the separate job-token-authored receipt as implemented. It removes duplicate work while keeping the trusted credential outside the sandbox, verifies that receipt and agent identities differ, and fails open whenever authenticity or parsing is uncertain; the alternatives either preserve the duplication or cannot establish a safe authorship boundary.

Files changed (14) +1803 / -12

Enhancement (4) +570 / -7
run.goIntegrate receipt checks and posting into run lifecycle +41/-1

Integrate receipt checks and posting into run lifecycle

• Checks trusted receipts before start-comment and pre-script side effects, tracks acknowledged steers per iteration, publishes completion metadata, and posts a success-only receipt after final deferred outcomes are known.

internal/cli/run.go

steer.goImplement authenticated steer receipt processing +316/-4

Implement authenticated steer receipt processing

• Adds receipt credential gating, marker construction from acknowledged deliveries, identity-authenticated pre-flight checks, success and publication guards, best-effort receipt posting, and shipped-iteration selection. Unsupported or uncertain paths fall through to normal execution.

internal/cli/steer.go

statuscomment.goAttach steer metadata to terminal status comments +24/-2

Attach steer metadata to terminal status comments

• Adds optional steer markers to completion comments while excluding them from visible status text and centralizing status-marker prefix handling.

internal/statuscomment/statuscomment.go

steermarker.goAdd steer marker parsing and sanitization +189/-0

Add steer marker parsing and sanitization

• Introduces normalized steer marker construction, parsing, consumed-run lookup, latest trusted-author selection, and idempotent neutralization of agent-supplied fullsend marker syntax.

internal/statuscomment/steermarker.go

Bug fix (2) +52 / -4
issues.goNeutralize markers in tracker sticky comments +10/-2

Neutralize markers in tracker sticky comments

• Escapes agent-supplied fullsend markers before posting and sanitizes historical bodies while preserving trusted sticky-comment markers.

internal/cli/issues.go

sticky.goDefang forged markers in sticky output history +42/-2

Defang forged markers in sticky output history

• Neutralizes markers in new agent output and legacy history while preserving runner-owned prefixes and footer delimiters required by sticky-comment updates.

internal/sticky/sticky.go

Tests (4) +984 / -0
issues_test.goTest tracker marker neutralization +24/-0

Test tracker marker neutralization

• Verifies that tracker comments retain their own marker while planted steer receipts become unparsable.

internal/cli/issues_test.go

steer_test.goCover receipt trust, lifecycle, and failure paths +628/-0

Cover receipt trust, lifecycle, and failure paths

• Adds comprehensive tests for credential isolation, author collisions, forged markers, acknowledged batches, shipped iterations, success gating, GitLab behavior, best-effort posting, and fail-open checks.

internal/cli/steer_test.go

steermarker_test.goTest steer marker integrity and authentication +306/-0

Test steer marker integrity and authentication

• Covers marker normalization and parsing, author-based receipt selection, App and user forgery rejection, status-comment rendering, and marker-neutralization evasions.

internal/statuscomment/steermarker_test.go

sticky_test.goTest safe sticky-history neutralization +26/-0

Test safe sticky-history neutralization

• Ensures trusted sticky markers remain removable while smuggled steer markers are escaped and cannot accumulate in visible history.

internal/sticky/sticky_test.go

Documentation (4) +197 / -1
0120-receipt-the-absorbed-update-under-the-job-token.mdRecord the authenticated steer-receipt decision +100/-0

Record the authenticated steer-receipt decision

• Adds ADR 0120 covering the duplicate-run problem, evaluated alternatives, job-token trust boundary, success-only receipt policy, fail-open behavior, and GitLab limitation.

docs/ADRs/0120-receipt-the-absorbed-update-under-the-job-token.md

architecture.mdAdd steer receipts to the coordination architecture +8/-0

Add steer receipts to the coordination architecture

• Documents how absorbed updates are receipted and how queued runs use authenticated receipts to avoid duplicate agent execution.

docs/architecture.md

steering.mdDocument receipt mechanics and security boundaries +84/-0

Document receipt mechanics and security boundaries

• Explains receipt syntax, pre-flight skipping, credential isolation, identity comparison, failure direction, iteration selection, and the GitLab no-op behavior.

docs/contributing/steering.md

security-threat-model.mdModel forged steer receipts as a work-loss threat +5/-1

Model forged steer receipts as a work-loss threat

• Extends the event-deduplication threat model with authenticated receipts and explains why the sandbox must not control their author identity.

docs/problems/security-threat-model.md

@fullsend-ai-review

fullsend-ai-review Bot commented Sep 18, 2026 •

Copy link
Copy Markdown

🤖 Review · ⚠️ Cancelled · Started 3:11 PM UTC · Ended 3:31 PM UTC

Commit: 3b1b6bc · View workflow run →

@qodo-code-review

qodo-code-review Bot commented Sep 18, 2026 •

Copy link
Copy Markdown

Code Review by Qodo

🐞 Bugs (0) 📘 Rule violations (0) 🔗 Cross-repo conflicts (0) 📜 Skill insights (0)

Grey Divider


Action required

1. Queued updates can be dropped ✓ Resolved
Description
runAgent defers posting a steer receipt based on shouldPostSteerReceipt, but that predicate does
not account for noPostScript, allowing a successful run to sign a receipt even though its
configured publishing post-script was deliberately withheld. In GitHub Actions with steering
enabled, a fullsend run --no-post-script invocation that absorbs a follow-up names the consumed
run in the receipt, so the queued run accepts it and exits without processing or publishing its
update.
Code

internal/cli/run.go[R1323-1327]

+	defer func() {
+		if !shouldPostSteerReceipt(runErr, ctx.Err(), runSkipped, transcriptErrorOverride) {
+			return
+		}
+		postSteerReceipt(ctx, baseSteerOpts, steerMarker)
Relevance

●●● Strong

Accepted precedent requires withholding downstream effects when post-script is skipped; receipt
would falsely suppress queued work.

PR-#279
PR-#7234

ⓘ Recommendations generated based on similar findings in past PRs

Evidence
The CLI defines --no-post-script as suppressing post-script execution, and the post-script defer
returns immediately when noPostScript is set without setting runErr. However, the receipt defer
calls shouldPostSteerReceipt without that value, and the predicate checks only run errors,
cancellation, pre-script skipping, and transcript errors; because the action documentation
identifies post-scripts as performing publishing and security-gate side effects, a successful run
can emit a receipt despite never entering the publishing path.

internal/cli/run.go[1323-1327]
internal/cli/run.go[1859-1865]
internal/cli/steer.go[680-695]
internal/cli/steer.go[711-740]
internal/cli/steer.go[621-640]
internal/cli/run.go[459-485]
internal/cli/run.go[1860-1864]
internal/cli/run.go[1323-1328]
internal/cli/steer.go[687-695]
action.yml[425-435]

Agent prompt
The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
A successful run launched with `--no-post-script` can write a steer receipt even though its configured publishing post-script was deliberately skipped. That receipt causes the queued follow-up run to skip work that was never published.

## Fix Focus Areas
- internal/cli/run.go[1311-1328]
- internal/cli/run.go[1858-1865]
- internal/cli/steer.go[680-695]
- internal/cli/steer_test.go[1099-1123]

## Recommended Fix
Track whether a configured post-script was deliberately withheld and pass that state into `shouldPostSteerReceipt`, or add an equivalent output-published condition to the receipt gate. Return false when `h.PostScript` is configured but `--no-post-script` prevented it from running, and add a regression test proving that a successful absorbed steer with `noPostScript=true` cannot emit a receipt.

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools



Remediation recommended

2. Receipt logic breaks forge conventions ✗ Dismissed
Description
steerMarkerClientFn and steerReceiptClientFn construct newGitHubLiveClient behind new local
interfaces instead of receiving the shared forge.Client. Receipt reads and writes now depend on a
parallel abstraction, so later forge-wide behavior changes can miss this path.
Code

internal/cli/steer.go[R62-63]

+	steerMarkerClientFn  = func(token string) steerMarkerReader { return newGitHubLiveClient(token, "") }
+	steerReceiptClientFn = func(token string) steerReceiptWriter { return newGitHubLiveClient(token, "") }
Relevance

●●● Strong

Recent accepted forge precedents favor forge-neutral abstractions and shared forge.Client usage over
GitHub-specific CLI seams.

PR-#2415
PR-#6004

ⓘ Recommendations generated based on similar findings in past PRs

Evidence
Compliance rule 1062052 requires forge operations to use forge.Client and requires new call sites
to receive that client through dependency injection. The changed lines instead create concrete
GitHub live clients for both receipt operations.

Rule 1062052: Route all git forge operations through forge.Client
internal/cli/steer.go[58-63]
internal/cli/steer.go[499-512]

Agent prompt
The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
The new receipt reader and writer construct GitHub clients behind local interfaces rather than routing forge operations through the shared `forge.Client` abstraction.

## Fix Focus Areas
- internal/cli/steer.go[58-63]
- internal/cli/steer.go[499-512]

## Recommended Fix
Inject `forge.Client` instances into the receipt read and write paths, and remove the parallel client constructors and interfaces where the shared abstraction already provides the required comment and identity operations.

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools


Grey Divider

Context sources
✅ Compliance rules (platform): 72 rules
✅ Cross-repo context — repo relationships
  Explored: repo: fullsend-ai/.fullsend (sha: 7c163cad)
  Explored: repo: fullsend-ai/agents (sha: 8eb4b4ba)
Review mode: 🧠 Deep: This is a security- and concurrency-sensitive behavioral change with substantial new logic across multiple runtime paths, authentication boundaries, parsing, lifecycle gates, and integrations, creating a dense set of independently missable defects.

Grey Divider

Tip of the day
💡 Did you know, you can route each severity your way: inline, summary, both, or drop

More tips ↗ | Customize Qodo ↗ | Qodo docs ↗

Grey Divider

Qodo Logo

Comment thread internal/cli/steer.go Resolved
Comment thread internal/cli/run.go Resolved
@fullsend-ai-review

fullsend-ai-review Bot commented Sep 18, 2026 •

Copy link
Copy Markdown

🤖 Finished Review · ✅ Success · Started 3:32 PM UTC · Completed 4:12 PM UTC

Commit: bf569fe · View workflow run →

Runtime: pi · Model: sonnet → claude-sonnet-5 · Effort: high · Cost: $20.62

@codecov

codecov Bot commented Sep 18, 2026 •

Copy link
Copy Markdown

Codecov Report

❌ Patch coverage is 94.06780% with 21 lines in your changes missing coverage. Please review.

Files with missing lines Patch % Lines
internal/cli/review_skip.go 91.05% 7 Missing and 4 partials ⚠️
internal/cli/steer.go 93.84% 6 Missing and 2 partials ⚠️
internal/sticky/sticky.go 87.50% 1 Missing and 1 partial ⚠️

📢 Thoughts on this report? Let us know!

@fullsend-ai-review fullsend-ai-review Bot added the risk/elevated PR risk: elevated label Sep 18, 2026
@fullsend-ai-review

fullsend-ai-review Bot commented Sep 18, 2026 •

Copy link
Copy Markdown

Risk Assessment: moderate (2/5)

Details

Large blast radius (23 files, 3341 lines) and hotspot churn on run.go and sandbox.go are offset by a solid 0.30 test ratio, zero protected-path hits, no CI or dependency changes, opt-in feature gating, and established contributor status, preserving the moderate (2/5) assessment from prior review rounds.

Previous run

Risk Assessment: moderate (2/5)

Details

Large blast radius (23 files, 3341 lines) and hotspot churn on run.go and sandbox.go are offset by a solid 0.30 test ratio, zero protected-path hits, no CI or dependency changes, opt-in feature gating, and established contributor status, preserving the moderate (2/5) assessment from prior review rounds.

Previous run (2)

Risk Assessment: moderate (2/5)

Details

Large blast radius (23 files, 3344 lines) and hotspot churn on run.go and sandbox.go are offset by a solid 0.30 test ratio, zero protected-path hits, no CI or dependency changes, opt-in feature gating, and established contributor status, preserving the moderate (2/5) assessment from prior review rounds.

Previous run (3)

Risk Assessment: moderate (2/5)

Details

Large blast radius (21 files, 3173 lines) offset by a healthy ~0.29 test ratio, zero protected-path hits, no CI/dependency changes, and an established contributor; two security-sensitive files (steer.go, review_skip.go touching job-token/credential-matching logic) and hotspot churn on run.go/steer.go are balanced by issue-scope alignment and no risk-elevating labels. Composite continues to round to 2 (moderate), matching prior rounds of this same PR.

Previous run (4)

Risk Assessment: moderate (2/5)

Details

Unchanged metadata signals (20 files, 3,167 lines, zero protected or security-sensitive paths, no CI or dependency changes, 0.30 test ratio) combined with opt-in default-disabled behavior preserve the composite score of 2 (moderate), balancing elevated churn and coupling on core runner hotspot files.

Previous run (5)

Risk Assessment: moderate (2/5)

Details

Unchanged metadata signals (20 files, 3,167 lines, zero protected or security-sensitive paths, no CI or dependency changes, 0.30 test ratio) combined with opt-in default-disabled behavior preserve the composite score of 2 (moderate), balancing elevated churn and coupling on core runner hotspot files.

Previous run (6)

Risk Assessment: moderate (2/5)

Details

Large diff across 20 files with high churn and coupling on runner hotspots is counterbalanced by zero protected or security-sensitive path modifications, no CI or dependency changes, a strong 0.30 test ratio, and default-disabled gating, anchored to the prior rounds moderate score.

Previous run (7)

Risk Assessment: moderate (2/5)

Details

Large diff across 20 files with high churn and coupling on existing runner hotspots is counterbalanced by zero protected or security-sensitive path changes, no CI or dependency modifications, a solid 0.30 test ratio, and default-disabled gating, anchored to the prior rounds moderate score.

Previous run (8)

Risk Assessment: moderate (2/5)

Details

Large diff across 20 files with high churn on existing runner and forge hotspots is offset by zero protected or security-sensitive path changes, no CI or dependency modifications, solid test ratio (0.30), and an established contributor, anchored to the prior rounds moderate score.

Previous run (9)

Risk Assessment: moderate (2/5)

Details

Large diff across 20 files with high churn on existing runner and forge hotspots is offset by zero protected or security-sensitive path changes, no CI or dependency modifications, solid test ratio (0.30), and an established contributor, anchored to the prior rounds moderate score.

Previous run (10)

Risk Assessment: moderate (2/5)

Details

Large diff across 20 files with high churn on existing runner and forge hotspots is offset by zero protected or security-sensitive path changes, no CI or dependency modifications, solid test ratio (0.30), and an established contributor, anchored to the prior round's moderate score.

Previous run (11)

Risk Assessment: moderate (2/5)

Details

Large diff across 20 files with high churn on existing runner and forge hotspots is offset by zero protected or security-sensitive path changes, no CI or dependency modifications, solid test ratio (0.30), and an established contributor, anchored to prior rounds moderate score.

Previous run (12)

Risk Assessment: moderate (2/5)

Details

Large diff across 20 files with high churn on existing runner and forge hotspots is offset by zero protected or security-sensitive path changes, no CI or dependency modifications, solid test ratio (0.30), and an established contributor, anchored to prior rounds moderate score.

Previous run (13)

Risk Assessment: moderate (2/5)

Details

Large diff (14 files, 2,340 lines) and elevated churn on existing core files (run.go, architecture.md) are counterbalanced by zero protected or security-sensitive path modifications, no CI or dependency changes, a 0.29 test ratio, and an established contributor, preserving the anchored score of 2 (moderate) under 62/38 Tier 1/Tier 2 weighting. This round is a pure rebase (all 14 files byte-identical to the prior anchored round) with no signal change.

Previous run (14)

Risk Assessment: moderate (2/5)

Details

Large diff (14 files, 2,340 lines) and elevated churn on existing core files (run.go, architecture.md) are counterbalanced by zero protected or security-sensitive path modifications, no CI or dependency changes, a 0.29 test ratio, and an established contributor, preserving the anchored score of 2 (moderate) under 62/38 Tier 1/Tier 2 weighting.

Previous run (15)

Risk Assessment: moderate (2/5)

Details

Large diff (14 files, 2,325 lines) and high churn on existing core files (run.go, architecture.md) elevate risk, but zero protected or security-sensitive path modifications, no CI or dependency changes, a 0.29 test ratio, and an established contributor preserve the anchored score of 2 (moderate) under 62/38 Tier 1/Tier 2 weighting, with this round's only delta being an isolated doc-comment update to gitlabMergeRequestHeadSHA.

Previous run (16)

Risk Assessment: moderate (2/5)

Details

Large diff (14 files, 2,325 lines) and high churn on existing core files (run.go, architecture.md) elevate risk, but zero protected or security-sensitive path modifications, no CI or dependency changes, a 0.29 test ratio, and an established contributor preserve the anchored score of 2 (moderate) under 62/38 Tier 1/Tier 2 weighting. This round closed a 12-round-standing low-severity credential-isolation gap (stripOIDCEnv now strips swapped-away tokens by value too), a risk-reducing change too small to move the rounded composite.

Previous run (17)

Risk Assessment: moderate (2/5)

Details

No linked issue (62/38 Tier1/Tier2 weighting): Tier1 (~1.88) reflects a large diff fully offset by zero protected/security-sensitive path hits, no CI/dependency changes, a 0.29 test ratio, and a known non-first-time author; Tier2 (~2.6) is pulled up by very high churn on run.go/architecture.md/security-threat-model.md but pulled down by brand-new files with no history. Composite rounds to 2 (moderate), preserving the prior anchored score; the newly-landed job-token receipt/credential-stripping logic is captured by run.go's already-elevated Tier2 churn score rather than by the path-pattern security heuristic, so no upward adjustment is warranted.

Previous run (18)

Risk Assessment: moderate (2/5)

Details

Tier 1 re-verified this round: identical bucket outcomes to the prior assessment (14 files, large blast radius, 0 protected/security paths, no CI/dependency changes, 0.29 test ratio, known non-first-time member author). Tier 2 churn on the two files with a genuine behavior delta since the prior review (statuscomment.go new settledSHA field/rendering change, paired with a new steermarker_test.go regression test) shows moderate per-file history, not elevated. With no linked issue (62/38 Tier1/Tier2 weighting), the composite rounds to 2, preserving the prior anchored score of 2 (moderate).

Previous run (19)

Risk Assessment: moderate (2/5)

Details

Tier 1 re-verified identical to the prior assessment (14 files, 2088 lines, large blast radius, 0 protected/security paths, no CI/dependency changes, 0.29 test ratio, known non-first-time member author); the only delta since the prior review is a comment-only reordering in run.go with no line-count or logic change. No linked issue, so weight remains 62/38 Tier1/Tier2. Score preserved at 2 (moderate) per re-review anchoring.

Previous run (20)

Risk Assessment: moderate (2/5)

Details

Composite = 0.62xTier1(1.88) + 0.38xTier2(2.29) = 2.03 -> 2 (moderate). Large diff (2088 lines/14 files) offset by zero protected-path and zero security-pattern-path hits, no CI/dependency changes, ~29% test ratio, and a known non-first-time maintainer; two long-lived hotspot files (run.go, docs/architecture.md) elevate churn/coupling signals. No issue is authoritatively linked, so weight was redistributed 62/38 to Tier1/Tier2.

Previous run (21)

Risk Assessment: elevated (3/5)

Details

Re-review anchoring holds: Tier 1 metadata is unchanged from the prior round (14 files, 2088 lines, large blast radius, no protected/dependency/CI changes, non-bot non-first-time author), and Tier 2 again shows run.go as an extremely hot, multi-author, fix/revert-heavy file while the new job-token trust-boundary code (steer.go, steermarker.go, ADR 0120) still has zero base-branch commit history since it was added within this same long-running PR. No signal has changed since the prior review that would justify moving off the anchored elevated score of 3.

Previous run (22)

Risk Assessment: elevated (3/5)

Details

Re-review anchoring: Tier 1 metadata is unchanged from the prior round (14 files, ~2085 lines, large blast radius, no protected/dependency-file changes, no CI changes, non-bot non-first-time author), and Tier 2 independently reproduces the same elevated picture -- run.go remains an extremely hot, multi-author, fix/revert-heavy file, and the new job-token trust-boundary code (steer.go, steermarker.go) still has zero base-branch commit history. No signal has changed since the prior review that would justify moving off the anchored elevated score of 3.

Previous run (23)

Risk Assessment: elevated (3/5)

Details

Tier 1 metadata is essentially unchanged from the prior review (14 files, ~2078 lines, large blast radius, no protected/dependency-file changes), and Tier 2 independently reproduces the prior round's elevated picture -- run.go remains an extremely hot file (102 commits/30d, 17 authors, 164 fix/revert commits/90d) and the new job-token trust-boundary code (steer.go, steermarker.go) still has zero base-branch commit history -- so per re-review anchoring the prior elevated score is preserved. Review found the medium nested-mint credential-isolation gap from the prior round fixed, but a low-severity variant of the same class of gap (validation-script environment composition) remains open.

Previous run (24)

Risk Assessment: elevated (3/5)

Details

Tier 1 metadata is essentially unchanged from the prior review (14 files/~1957 lines, large blast radius, no protected/dependency changes) and trends moderate alone, but Tier 2 independently reproduces the prior round's elevated picture: high churn/fix-revert density on core touched files, broad change-coupling to untouched files, and the new job-token trust boundary code remains entirely without base-branch history. This round is again a fix-up attempt, and review found the nested-mint credential-isolation gap still present, so the elevated score is preserved.

Previous run (25)

Risk Assessment: elevated (3/5)

Details

Tier 1 metadata is essentially unchanged from the prior review (14 files / ~1947 lines, large blast radius, no protected/dependency changes) and raw weighted composite alone would round to moderate, but Tier 2 shows elevated churn and fix/revert history on the core files this PR touches, and the security-critical steer/steermarker files carrying the new job-token trust boundary remain entirely absent from base-branch git history -- the same condition that drove the prior elevated score. This round is a fix-up addressing two prior High findings, but review found the fix incomplete (a nested-mint edge case reopens the credential-isolation gap), so the qualitative risk of this unverified trust boundary is preserved and the score is kept at elevated rather than lowered.

Previous run (26)

Risk Assessment: elevated (3/5)

Details

Large-blast-radius change (1815 lines/14 files, weighted composite ~2.2 rounds to moderate) is bumped to elevated because its highest-risk component is an entirely new job-token-authenticated trust boundary with no git history to assess, and review found a real fail-open defect (--no-post-script) plus a credential-isolation gap (GITHUB_TOKEN) in that exact boundary.

@fullsend-ai-review

fullsend-ai-review Bot commented Sep 18, 2026 •

Copy link
Copy Markdown

Review

Findings

High

  • [incorrect-doc] docs/contributing/steering.md:100 — Lines 100–101 of the new head-move paragraph claim that when a move is "cut off" by "the steer budget," it is not taken as told: lastHead stays put and the next steer reports the same move again. That is not what the watcher does, and the sentence sits immediately after the inner head-move comparison cuts ("a file list longer than the head-move budget"; patches bounded with the cut stated), so a reader applies the pinned-head rule to the wrong budget. Independently re-checked against the PR-base internal/steerwatch sources (not part of this PR's diff, but the behavior this new prose describes): maxHeadMoveBytes (6 KiB, delta.go) is the inner compare cap; maxDeltaBytes (16 KiB) is the outer envelope shared with amendments/comments. headMoveContext treats a listing that exceeds maxHeadMoveBytes the same as a force-push, a 300-file cap, or a forge error: it returns a complete "could not be read / read the pull request yourself" item (the listing-overflow reason even says "longer than the steer budget"). Patch overflow still delivers the full file listing plus a stated cut. In both inner-budget cases, buildText leaves headClipped=false, and markSteered runs if d.headMoved && !w.headClipped { w.lastHead = d.newHead } — the head still advances. TestHeadBaselineAdvancesOnDelivery uses the same unreadable/no-compare fixture as the force-push case and asserts the baseline advances, so the next delta does not repeat the move. lastHead is held only when the outer envelope budget (maxDeltaBytes) clips the entire head-move item out of the message (headClipped=true), which is what TestHeadBaselineHoldsWhenTheListingWasClipped covers — that scenario is driven by amendments exhausting the envelope, not by the file list exceeding maxHeadMoveBytes. Believing the current sentence would lead an engineer or on-call reader to expect a retry of an unreadable/truncated compare that the watcher will never send. This finding was independently identified by both the correctness and docs-currency review dimensions and confirmed by an adversarial re-check against the cited tests.
    Remediation: Split the two budgets in the prose and do not call maxHeadMoveBytes "the steer budget" in the same sentence as the pinned-head rule. (1) An unreadable compare — force-push, listing at the 300-file cap, file list longer than maxHeadMoveBytes, or a forge error — is delivered as "could not be read"; lastHead advances and the next steer does not repeat the move. A listing or patches that exceed the head-move budget is still delivered (unreadable notice, or partial patches with the cut stated) and advances the head baseline. (2) Only when maxDeltaBytes clips the head-move item out of the envelope — typically because amendments exhausted the room — is the move not taken as told, lastHead stays, and the next steer reports it again.

Notes

  • This is a re-review. The immediately-prior review round (head 738918affd3bae02371fb950b81e880a123ac44a) found zero findings ("Looks good to me"). GitHub's compare API reports diverged between that head and this one (ahead_by: 11, behind_by: 11) — the same rebase/stacked-branch artifact (base branch steer-monitor, not main) this PR's long review history has repeatedly hit — so per-file git blob-SHA comparison was used instead. That comparison shows only one file changed since the prior round: docs/contributing/steering.md (the other 22 of 23 files are byte-identical to the prior reviewed round).
  • Per the re-review dispatch rules, correctness ran at its always-full scope, style-conventions ran at trivial scope (no prior findings), and docs-currency re-qualified for normal-scope dispatch because the one changed file is documentation. security, intent-coherence, and cross-repo-contracts were not re-dispatched: the sole changed file is a documentation-only edit that does not touch auth/config/secret-handling paths, does not implement behavior the linked issue makes claims about, and does not touch forge.Client or other cross-repo contract surface.
  • The finding above concerns prose describing behavior implemented in internal/steerwatch/delta.go and internal/steerwatch/watcher.go, which live on this PR's base branch (steer-monitor) and are not part of this PR's diff. Both correctness and docs-currency fetched and read those files directly via the GitHub contents API (they are not in the local checkout, which tracks main) to verify the claim against the actual code and its tests before reporting.
  • No protected paths (per the active REVIEW_PROTECTED_PATHS list) are touched — all 23 changed files are under docs/ or internal/.
  • No injection patterns or non-rendering Unicode were found in the PR title, body, or commit messages. Both commits carry Signed-off-by trailers, consistent with a human-directed, Claude-assisted session under this repo's DCO policy.
  • PR metadata verified via the GitHub API: draft: false, labels security, fullsend-no-fix, ready-for-merge, component/runner, risk/moderate.
  • Risk assessment: moderate (2/5), anchored to the prior rounds' stable score. Tier 1 (62% weight, no formally-linked closing issue in the API sense — issue Steer the in-flight agent run on work-item updates instead of cancelling it #6957 is closed as completed) reflects a large diff (23 files, 3341 lines, large blast radius) offset by zero protected/security-sensitive path hits, no CI/dependency changes, a 0.30 test ratio, and an established contributor. Tier 2 (38% weight) shows continued churn on long-lived hotspot files (run.go, sandbox.go). The composite continues to round to 2 (moderate).

Next steps:

  • /fs-fix — agent addresses review findings automatically
  • /fs-fix <your instruction> — agent fixes with your specific guidance
  • Push commits directly — review re-runs automatically on push
  • /fs-fix-stop — disable automatic fix runs for this PR
Previous run

Looks good to me

Previous run (2)

Looks good to me

Previous run (3)

Looks good to me

Previous run (4)

Review

Findings

Low

  • [auth-bypass] internal/cli/steer.go:822 — steerReceiptsHonoured still scans only harness.LoadProviderDefs(providersDir) (on-disk .fullsend/providers/*.yaml). Credential provisioning later merges URL-resolved provider definitions via mergeProviderDefs(localDefs, result.Providers) (internal/cli/run.go), and can attach them to a sandbox, so a URL-fetched provider that expands GH_WORKFLOW_TOKEN is never inspected by this gate. This is the documented, accepted limitation in ADR 0120 ("one fetched by URL is not inspected"), unchanged in substance from every prior review round on this PR.
    Remediation: If the limitation is no longer acceptable, inspect result.Providers (and any embedded defs expanding GH_WORKFLOW_TOKEN) in the same gate, or refuse receipts whenever any URL-resolved provider is attached. Otherwise this is fine to leave as the documented ADR 0120 bound.

  • [sub-agent-failure] N/A — The challenger sub-agent returned an empty adjudicated_findings array against the one non-empty finding sent to it, arguing the auth-bypass finding above restates an ADR-documented, accepted scan boundary rather than a defect — the same reasoning and outcome as several earlier review rounds' challenger passes on this identical finding. Per orchestrator policy, an empty adjudicated set for a non-empty input is treated as a challenger failure regardless of the reasoning offered, since a legitimate pass removing every finding is indistinguishable from a parsing error or context truncation. The pre-challenger finding set (the auth-bypass finding above) was used as-is.

Notes

  • This is a re-review. PRIOR_REVIEW_SHA (7632158ff4bd96e5eae379abac3541ccff4bb88e) compared against the current head (0cdccc07cc8ea0831aedd9328c4e73cc9bfb57c9) returned status: diverged from GitHub's compare API (ahead_by: 146, behind_by: 23) — the same rebase/stacked-branch artifact this PR's long review history has repeatedly hit (base branch is steer-monitor, not main). Per-file git blob-SHA comparison was used instead: 12 of 23 files changed since the prior round (docs/ADRs/0120-*.md, docs/architecture.md, docs/cli/steer.md, docs/contributing/steering.md, docs/problems/security-threat-model.md, internal/cli/run.go, internal/cli/steer.go, internal/cli/steer_test.go, internal/forge/forge.go, internal/forge/github/github.go, internal/sandbox/sandbox.go, internal/sandbox/sandbox_test.go); the other 11 files are byte-identical to the prior reviewed round.
  • correctness (always full scope on re-review) traced the receipt/skip-check wiring, the credential-strip mechanism, and — new this round — internal/sandbox/sandbox.go's ExtractOutputFiles hardening (distinguishing an openshell non-zero exit from a genuinely empty listing, and treating "files listed but none copied" as an error), including how that return value gates shouldPostSteerReceipt's "output was published" precondition. No findings.
  • security (normal scope, re-verifying the prior auth-bypass finding) independently re-confirmed steerReceiptsHonoured is unchanged in substance and the gap is still the ADR 0120 bound; its structured output omitted the finding, which the orchestrator treated as a formatting gap rather than a resolution (the function is unchanged in the PR-head tree, independently confirmed by direct read) and carried the finding forward per severity-anchoring rules.
  • intent-coherence (re-qualified: changed-since-prior includes core mechanism files implementing behavior issue Steer the in-flight agent run on work-item updates instead of cancelling it #6957 and this PR's own ADR 0120 make claims about) traced the implementation against both issue Steer the in-flight agent run on work-item updates instead of cancelling it #6957's original proposal and ADR 0120's stated rationale for diverging from it (a comment marker shares an identity with agent output and is forgeable by prompt injection; job-token authentication avoids that), found no scope-creep or coherence issues.
  • docs-currency (re-qualified: 5 documentation files changed since the prior round) re-verified that docs/contributing/steering.md and docs/ADRs/0120-*.md accurately and completely describe the receipt/skip mechanism, credential handling, and the new ExtractOutputFiles "output must actually be copied" check. No findings.
  • cross-repo-contracts (re-qualified: internal/forge/forge.go and internal/forge/github/github.go changed since the prior round) confirmed this round's hunks are the same already-reviewed, additive PullRequestReview.CommitID field reintroduced by a rebase, not a new contract change. No findings.
  • style-conventions (trivial scope, no prior findings) found no issues.
  • No protected paths (per the active REVIEW_PROTECTED_PATHS list) are touched — all 23 changed files are under docs/ or internal/.
  • No injection patterns or non-rendering Unicode were found in the PR title or body.
  • PR metadata verified via the GitHub API: draft: false, labels security, fullsend-no-fix, ready-for-merge, component/runner, risk/moderate.
  • Risk assessment: moderate (2/5), anchored to the prior rounds' stable score. Tier 1 (62% weight, no formally-linked closing issue) reflects a large diff (23 files, 3344 lines, large blast radius) offset by zero protected/security-sensitive path hits by the path-pattern heuristic, no CI/dependency changes, a 0.30 test ratio, and an established contributor. Tier 2 (38% weight) shows elevated churn and fix/revert history on long-lived hotspot files (run.go, forge.go) balanced by low revert frequency and low workaround/hack sentiment. The composite continues to round to 2 (moderate).
Previous run (5)

Review

Findings

Low

  • [auth-bypass] internal/cli/steer.go:826 — steerReceiptsHonoured still scans only harness.LoadProviderDefs(providersDir) (on-disk .fullsend/providers/*.yaml). Credential provisioning later merges URL-resolved provider definitions via mergeProviderDefs(localDefs, result.Providers) (internal/cli/run.go:1536) and can attach them to a sandbox, so a URL-fetched provider that expands GH_WORKFLOW_TOKEN is never inspected by this gate. Because every job in the repo posts receipts under the same login, a sandbox that recovers that token via any harness in the repo could forge a receipt the queued run would honour. This is the documented, accepted limitation in ADR 0120 ("one fetched by URL is not inspected"), not an accidental omission — fail-open for unreadable local defs is otherwise fail-closed (empty/missing dir = no entries = receipts honoured; parse error refuses).
    Remediation: If the limitation is no longer acceptable, inspect result.Providers (and any embedded defs expanding GH_WORKFLOW_TOKEN) in the same gate, or refuse receipts whenever any URL-resolved provider is attached. Otherwise this is fine to leave as the documented ADR 0120 bound.

Notes

  • This is a re-review. PRIOR_REVIEW_SHA (7a25772198b43e2cad1209c777d679f5a1baa566, whose review found zero findings — "Looks good to me") compared against the current head (7632158ff4bd96e5eae379abac3541ccff4bb88e) returned status: diverged (ahead_by: 11, behind_by: 11) — a non-linear-history/rebase artifact this PR's review history has repeatedly hit. No incremental file-level anchoring was possible; this round evaluated the full current diff (21 files, 3173 lines) independently. All six dimensions (correctness, security, intent-coherence, style-conventions, docs-currency, cross-repo-contracts) were dispatched at full/standard scope.
  • Tooling note: the first correctness dispatch timed out after 900s. It was retried with a time-boxed, priority-ordered read plan (core mechanism files first, tests next, docs last); the retry completed within budget, traced steerReceiptToken/shouldPostSteerReceipt/steerAlreadyHandled and headAlreadyReviewed/runPreflightSkips's producer→consumer paths, and reported no findings.
  • Tooling note — base branch mismatch: this PR's base branch is steer-monitor (a stacked feature branch), not main; the sandbox checkout at target-repo/ tracks main, which lags steer-monitor. Sub-agents were explicitly instructed to rely on pr-diff.txt hunks rather than diffing against target-repo/, to avoid the false-positive pattern a prior review round hit under this same condition. No false positives of that kind were reported this round.
  • security (full scope) re-verified the one auth-bypass finding above and confirmed it is unchanged in substance from earlier review rounds; found no other issues, including in the App-login matching and job-token capture logic added by this PR.
  • intent-coherence traced the PR's job-token-receipt design back to ADR 0120's stated divergence from issue Steer the in-flight agent run on work-item updates instead of cancelling it #6957's original comment-marker proposal (comment-marker text shares an identity with agent output and is forgeable by prompt injection), found the design well-justified, internally consistent with ADR 0113/0106/0114/0044, and found no scope-creep or coherence issues.
  • cross-repo-contracts (dispatched: internal/forge/forge.go's additive PullRequestReview.CommitID field) confirmed the change is backward-compatible; GitLab's ListPullRequestReviews never populates CommitID (consistent with the field's documented "empty when the forge does not report it" contract), and the only new consumer (headAlreadyReviewed) short-circuits for GitLab before the field is read — no cross-forge contract issue.
  • docs-currency and style-conventions found no issues.
  • No protected paths (per the active REVIEW_PROTECTED_PATHS list) are touched — all 21 changed files are under docs/ or internal/.
  • No injection patterns were found in the PR title or body.
  • PR metadata verified via the GitHub API: draft: false, labels security, fullsend-no-fix, ready-for-merge, component/runner, risk/moderate.
  • Risk assessment: moderate (2/5), anchored to the prior rounds' stable score — Tier 1 (large blast radius offset by ~0.29 test ratio, zero protected-path hits, two security-sensitive files, no CI/dependency changes, established contributor) combined with Tier 2 churn/coupling on long-lived hotspot files (run.go, steer.go) and Tier 3 (issue scope matches, no risk-elevating labels) continues to round to 2 (moderate).
Previous run (6)

Looks good to me

Previous run (7)

Review

Findings

Low

  • [auth-bypass] internal/cli/steer.go:820 — steerReceiptsHonoured still only scans harness.LoadProviderDefs(providersDir) (local .fullsend/providers/*.yaml). It does not inspect result.Providers, which runAgent later merges via mergeProviderDefs (run.go:1536). A URL-fetched provider that expands GH_WORKFLOW_TOKEN therefore cannot disable receipt-based skipping. This is the documented, accepted limitation in ADR 0120 ("one fetched by URL is not inspected"). Independently re-confirmed this round: listIssueComments still copies UpdatedAt (github.go), and stripOIDCEnv still drops entries via strippedByValue (run.go).
    Remediation: If URL-resolved provider definitions are meant to be covered too, extend steerReceiptsHonoured to also scan result.Providers for a workflow-token-expanding credential value, and update ADR 0120's disclosure if the intent is to close this gap rather than accept it.
Previous run (8)

Review

Findings

Low

  • [auth-bypass] internal/cli/steer.go:820 — steerReceiptsHonoured, the gate that disables receipt-based skipping when a provider can hand the GitHub Actions job token to a sandbox (recoverable per ADR 0114), still scans only harness.LoadProviderDefs(providersDir) (the local .fullsend/providers/*.yaml files). It does not inspect result.Providers, the run's URL-resolved provider definitions merged later in runAgent via mergeProviderDefs, so a URL-fetched provider that expands GH_WORKFLOW_TOKEN is not checked and cannot disable the receipt-based skip. This is a documented, accepted limitation rather than a silent gap — ADR 0120 states explicitly that "one fetched by URL is not inspected" — and the function is unchanged in substance from the prior review round.
    Remediation: If URL-resolved provider definitions are meant to be covered too, extend steerReceiptsHonoured to also scan result.Providers for a workflow-token-expanding value, and update ADR 0120's disclosure if the intent is in fact to close this gap rather than accept it.

  • [sub-agent-failure] N/A — The challenger sub-agent returned an empty adjudicated_findings array for the one non-empty finding sent to it (it argued the auth-bypass finding above restates an ADR-documented, accepted scan boundary rather than a defect — the same reasoning and outcome as the immediately-prior review round's challenger pass). Per orchestrator policy, an empty adjudicated set for a non-empty input is treated as a challenger failure regardless of the reasoning offered, since a legitimate pass removing every finding is indistinguishable from a parsing error or context truncation. The pre-challenger finding set (the auth-bypass finding above) was used as-is.

Notes

  • This is a re-review. PRIOR_REVIEW_SHA (d1e26adccd72ca95f7749d2635261d2ee5a8b9ce) compared against the current head (eb62c522df9ab9dee5c1ab35c11a504e65040e0e) returned status: diverged (ahead_by: 23, behind_by: 23) — the same rebase/history-rewrite artifact this PR's long review history has repeatedly hit, not a usable incremental diff. No file-level anchoring was possible; this round evaluated the full current diff (20 files, 3167 lines — file and line counts identical to the prior round's) independently, with correctness and security at full scope and intent-coherence, docs-currency, and cross-repo-contracts re-qualified and dispatched under the base classification criteria (a linked design-provenance issue, Steer the in-flight agent run on work-item updates instead of cancelling it #6957; changed documentation files; and a changed shared forge.Client data type, respectively). style-conventions dispatched at trivial scope (no prior findings).
  • Tooling note — base branch mismatch: this PR's base branch is steer-monitor (a stacked feature branch), not main; the sandbox checkout at target-repo/ tracks main, which lags steer-monitor. The docs-currency sub-agent's initial pass, using target-repo/ as "the base branch," reported two findings — a missing "Run baseline" section in docs/cli/run.md, and a missing docs/contributing/steering.md entry in AGENTS.md's topic table. Fetching the real base ref (steer-monitor) via the GitHub contents API showed both already exist there (added by an earlier, already-merged PR in the same stack) — this PR does not touch either file and doesn't need to. Both findings were false positives and are not included above. This is a review-tooling issue specific to stacked-branch PRs, not a PR defect.
  • Tooling note — correctness timeout: the first correctness dispatch timed out after 900s. It was retried with a time-boxed, priority-ordered read plan (new/changed Go logic first, documentation last); the retry completed and traced steerReceiptToken/shouldPostSteerReceipt/steerAlreadyHandled and headAlreadyReviewed/runPreflightSkips's producer→consumer paths, confirming both skip mechanisms fail open correctly and are pinned by tests, with no findings.
  • security (full scope, re-dispatched with the prior finding for anchoring) independently re-verified forge.IssueComment.UpdatedAt decoding/population (listIssueComments) and stripOIDCEnv's strippedByValue call remain in place from earlier fixed rounds, and preserved the one auth-bypass finding above at its prior (low) severity, unchanged.
  • intent-coherence (dispatched: linked issue Steer the in-flight agent run on work-item updates instead of cancelling it #6957 plus this PR's own new ADR) traced the PR's job-token-receipt design back to ADR 0120's stated rationale for diverging from Steer the in-flight agent run on work-item updates instead of cancelling it #6957's original comment-marker proposal (comment-marker text shares an identity with agent output and is thus forgeable by prompt injection), found the design change well-justified and consistent with the repo's threat model, re-confirmed the earlier deprecated-architecture finding (ADR 0044 framing) stays resolved, and found no other coherence issues.
  • cross-repo-contracts (dispatched: internal/forge/forge.go's shared PullRequestReview.CommitID field) confirmed the addition is additive/backward-compatible, that GitLab has no ListPullRequestReviews implementation to diverge, and that the new consumer (headAlreadyReviewed, via appReviewedHeadSince) is internal to internal/cli. No findings.
  • style-conventions (trivial scope) found no issues.
  • No protected paths (per the active REVIEW_PROTECTED_PATHS list) are touched — all 20 changed files are under docs/ or internal/.
  • No injection patterns were found in the PR title, body, or commit messages. Both commits carry Signed-off-by trailers and Assisted-by: Claude, consistent with a human-directed, Claude-assisted session under this repo's DCO policy.
  • PR metadata verified via the GitHub API: draft: false, labels security, fullsend-no-fix, ready-for-merge, component/runner, risk/moderate.
  • Risk assessment: moderate (2/5), anchored to the prior rounds' stable score. Tier 1 (identical file/line counts to the prior round: 20 files, 3167 lines, large blast radius, zero protected/security-sensitive path hits, no CI/dependency changes, 0.30 test ratio, established contributor) is offset by Tier 2 churn/coupling on long-lived hotspot files (run.go, steer.go). The composite continues to round to 2 (moderate).
Previous run (9)

Review

Findings

Low

  • [auth-bypass] internal/cli/steer.go:820 — steerReceiptsHonoured, the gate that disables receipt-based skipping when a provider can hand the GitHub Actions job token to a sandbox (recoverable per ADR 0114), scans only harness.LoadProviderDefs(providersDir) (the local .fullsend/providers/*.yaml files). It does not inspect result.Providers, the run's URL-resolved provider definitions merged earlier in runAgent via mergeProviderDefs, so a URL-fetched provider that expands GH_WORKFLOW_TOKEN is not checked and cannot disable the receipt-based skip. This is a documented, accepted limitation rather than a silent gap — ADR 0120 states explicitly that "one fetched by URL is not inspected" — and control flow here is unchanged since the prior review round.
    Remediation: If URL-resolved provider definitions are meant to be covered too, extend steerReceiptsHonoured to also scan result.Providers for a workflow-token-expanding value, and update ADR 0120's disclosure if the intent is in fact to close this gap rather than accept it.

  • [sub-agent-failure] N/A — The challenger sub-agent returned an empty adjudicated_findings array for a non-empty input (it argued the sole auth-bypass finding above restates an ADR-documented, accepted scan boundary rather than a defect). Per orchestrator policy, an empty adjudicated set for a non-empty input is treated as a challenger failure regardless of the reasoning offered, since a legitimate pass removing every finding is indistinguishable from a parsing error or context truncation. The pre-challenger finding set (the auth-bypass finding above) was used as-is.

Previous run (10)

Review

Findings

Low

  • [deprecated-architecture] internal/cli/review_skip.go:201 — The doc comment on headReviewedTransition explains why the transition kind is read from the delivered GitHub event rather than the normalized one by contrasting "a per-repo install" against "an org install['s] relay event," and the companion test case in internal/cli/review_skip_test.go:345 labels its workflow_dispatch case "an org relay". Per-org installation mode is deprecated (ADR 0044) and is being removed; per this repo's own conventions, new code and documentation should not engage with the org/repo-mode distinction as active architecture.
    Remediation: Reframe the comment and test case description around the actual mechanism (a workflow_dispatch payload does not represent an automated pull-request lifecycle transition, so it fails open without skipping) rather than the deprecated per-org relay framing.

  • [auth-bypass] internal/cli/steer.go:824 — steerReceiptsHonoured, the gate that disables receipt-based skipping when a provider can hand the GitHub Actions job token to a sandbox (recoverable per ADR 0114), scans only harness.LoadProviderDefs(providersDir) — the local .fullsend/providers/*.yaml files. It does not inspect result.Providers, the run's URL-resolved provider definitions (merged into the effective provider set earlier in runAgent via mergeProviderDefs), so a URL-fetched provider that expands GH_WORKFLOW_TOKEN is not checked and cannot disable the receipt-based skip. This is a real, narrower-than-advertised scan, but it is a documented, accepted limitation rather than a silent gap: ADR 0120 states explicitly ("one fetched by URL is not inspected"). Since every job in the repository posts receipts under the same login, exploiting this still requires a harness in the same repo to declare a URL-resolved provider expanding the workflow token — the same trust boundary ADR 0120 already accepts for local provider definitions — and the fail-open direction (an unnoticed leak lets receipts wrongly skip work) matches the risk ADR 0120 already assigns to the local-file case.
    Remediation: If URL-resolved provider definitions are meant to be covered too, extend steerReceiptsHonoured to also scan result.Providers (or wherever URL-resolved credentials are held at the point providersDir is captured) for a workflow-token-expanding value, and update ADR 0120's disclosure if the intent is in fact to close this gap rather than accept it.

  • [sub-agent-failure] N/A — The challenger sub-agent was skipped at the step 6d time-budget checkpoint (665s remaining, and the challenger pass itself typically costs 2.5–6 minutes, which risked missing the write deadline for this result). The pre-challenger finding set above was used as-is; both of its findings were independently re-verified by the orchestrator against the PR-head source directly (see below), which substitutes for challenger adjudication in this run.

Notes

  • This is a re-review. PRIOR_REVIEW_SHA (4ca475533e631f78f9186748463bdfa1d1ce0083) matched the prior review comment's current section, which found zero findings ("Looks good to me"). GitHub's compare API returned 404 for 4ca475533e631f78f9186748463bdfa1d1ce0083...8b4ba99c6b78e71bd6152ecf50ad72476ef5ede3 (the same history-rewrite/rebase artifact this PR's long review history has repeatedly hit), so no incremental file-level anchoring was possible — this round evaluated the full current diff (20 files, 3167 lines) independently, with correctness at full scope, style-conventions at trivial scope, and security, intent-coherence, docs-currency, and cross-repo-contracts re-qualified and dispatched under the base classification criteria (auth/token-handling surface, a design provenance issue (Steer the in-flight agent run on work-item updates instead of cancelling it #6957) plus a new Accepted ADR, changed documentation files, and a changed shared forge.Client data type, respectively).
  • Tooling note: the first materialisation of /sandbox/workspace/pr-head/ silently truncated 9 of 20 files (missing 5–10% of file bytes each, cutting off mid-function) due to a parallel-fetch race in the pre-fetch step. The initial correctness and security dispatches, run against that corrupted tree, produced three false high-severity findings claiming the receipt/skip mechanism was never wired into runAgent and that forge.PullRequestReview lacked its new fields — all artifacts of the truncation, not real defects. The tree was re-fetched via the GitHub git blobs API, every one of the 20 files was verified byte-exact against the git tree's recorded blob size, and correctness, security, and docs-currency were re-dispatched against the corrected tree; their outputs above reflect the verified code. This is disclosed for review-provenance transparency; it is a review-tooling issue, not a PR defect.
  • correctness (full scope, re-dispatched against the verified tree) traced steerReceiptToken, shouldPostSteerReceipt, steerAlreadyHandled, headAlreadyReviewed/runPreflightSkips and their single call site in runAgent, the swappedAwayTokens/strippedByValue by-value credential strip wired into both childScriptEnv and stripOIDCEnv, and the mintAgentTokenAtLevel swap of both GH_TOKEN and GITHUB_TOKEN with nested-mint-safe cleanup (swappedHere/forgetSwappedAwayToken) — all confirmed present and wired correctly. No findings.
  • security (normal scope, re-dispatched against the verified tree) independently confirmed forge.IssueComment.UpdatedAt is now decoded from GitHub's updated_at and populated in ListIssueComments, closing what would otherwise have been a real gap in steerAlreadyHandled's edited-comment rejection; confirmed stripOIDCEnv now calls strippedByValue, closing the validation_loop.script credential-isolation gap reported in every earlier round of this PR's review history; and found the one auth-bypass finding above.
  • intent-coherence (dispatched: design provenance issue Steer the in-flight agent run on work-item updates instead of cancelling it #6957 plus a new Accepted ADR in this same PR) found ADR 0120 self-authorizes the mechanism per this repo's ADR conventions and traces consistently to Steer the in-flight agent run on work-item updates instead of cancelling it #6957's proposed design, and found the one deprecated-architecture finding above.
  • style-conventions (trivial scope, no prior findings) found no issues.
  • docs-currency (dispatched: documentation files changed) re-verified, against the corrected tree, that docs/contributing/steering.md and docs/ADRs/0120-*.md's claims about by-value credential stripping, marker-neutralization scope, and the review-App identity match (login + AuthorIsApp) match the current code, and checked docs/architecture.md, docs/problems/security-threat-model.md, and other steering-adjacent docs (docs/cli/steer.md, prior ADRs) for staleness. No findings.
  • cross-repo-contracts (dispatched: internal/forge/forge.go's shared PullRequestReview type changed) confirmed the new CommitID field is additive and backward-compatible, that GitLab's unchanged ListPullRequestReviews implementation compiles unaffected (named-field struct literals, field defaults to empty), and that the one new consumer of CommitID (appReviewedHeadSince) is explicitly gated off for GitLab, so an always-empty field there cannot cause an incorrect skip. No findings.
  • No protected paths (per the active REVIEW_PROTECTED_PATHS list) are touched — all 20 changed files are under docs/ or internal/.
  • No injection patterns or non-rendering Unicode were found in the PR title, body, or commit messages. Commits carry Signed-off-by trailers consistent with the repo's DCO policy for a human-directed, Claude-assisted session (Assisted-by: Claude).
  • PR metadata verified via the GitHub API: draft: false, labels security, fullsend-no-fix, ready-for-merge, component/runner, risk/moderate.
  • Risk assessment: moderate (2/5), anchored to the prior rounds' stable score. Tier 1 (62% weight, no formally-linked closing issue) reflects a large diff (20 files, 3167 lines, large blast radius) offset by zero protected/security-sensitive path hits by the path-pattern heuristic, no CI/dependency changes, a 0.30 test ratio, and an established contributor. Tier 2 (38% weight) is elevated by high churn and fix/revert history on long-lived hotspot files (run.go, forge.go). The composite continues to round to 2 (moderate).

Next steps:

  • /fs-fix — agent addresses review findings automatically
  • /fs-fix <your instruction> — agent fixes with your specific guidance
  • Push commits directly — review re-runs automatically on push
  • /fs-fix-stop — disable automatic fix runs for this PR
Previous run (11)

Looks good to me

Previous run (12)

Looks good to me

Previous run (13)

Looks good to me

Previous run (14)

Review

Findings

Medium

  • [auth-bypass] internal/statuscomment/steermarker.go:163 — The job-token receipt skip trusts the current body of a comment matched only by author login, with no check that the body is still what it was when written. LatestSteerMarker (steermarker.go:159–163) walks comments newest-first, strings.EqualFold-matches Author, and parses whatever body is on the matched comment at read time. steerAlreadyHandled (internal/cli/steer.go:687-694) builds the []tracker.Comment it hands to LatestSteerMarker from forge.IssueComment using ID, Body, Author, and CreatedAt only — tracker.Comment has no UpdatedAt field, so an edit to an existing receipt comment's body is invisible to this path even though forge.IssueComment.UpdatedAt carries it (populated by internal/forge/github/github.go's listIssueComments). forge.IssueComment's own doc comment states the exact risk this creates: "the two [CreatedAt/UpdatedAt] differ for an edited comment, and the difference matters wherever a decision was made about the text: an authorization the original wording earned does not extend to a replacement." Whether this is currently exploitable turns on whether GitHub's PATCH /issues/comments/{id} lets an actor other than the comment's own author — e.g., the minted role token this same PR already treats as a distinct, lower-trust identity from the receipt token (steerAlreadyHandled's receiptLogin == roleLogin refusal) — edit a comment's body while leaving user.login unchanged. Not observed in current diff: any test or doc coverage of the edited-comment scenario.
    Remediation: Thread forge.IssueComment.UpdatedAt through the tracker.Comment conversion in steerAlreadyHandled (or bypass tracker.Comment for this path) and have LatestSteerMarker reject a matched comment whose UpdatedAt differs from its CreatedAt, failing open to "not handled" exactly as an unreadable timeline already does. Add a test asserting a syntactically valid receipt with UpdatedAt != CreatedAt does not trigger a skip. If investigation shows GitHub does not allow a non-author write-scoped identity to edit another actor's comment body, this finding can be closed instead — but ADR 0120 does not currently discuss comment-edit risk as an accepted boundary the way it discusses same-login receipt creation, so that check should happen before merge either way.

Low

  • [sub-agent-failure] N/A — The challenger sub-agent returned an empty adjudicated_findings array against a non-empty input set (the auth-bypass finding above), arguing in its removed_findings entry that GitHub's comment-update API is restricted to the comment's own author and that the cross-actor edit scenario therefore cannot occur. Per orchestrator policy, an empty adjudicated set against a non-empty input is treated as a challenger failure rather than a legitimate full removal — the permission-model claim was not independently confirmed against GitHub's documented behavior for App-authenticated tokens (which can differ from plain collaborator accounts) — so the pre-challenger finding set was kept unchanged instead of accepting the removal.

Notes

  • This is a re-review. The immediately-prior round (head 1ff9a96dd998ea96a2e1ba8ff43a959525187059) found zero findings ("Looks good to me"). GitHub's compare API reports diverged between that head and this one (the base branch is the long-lived steer-monitor feature branch, not main, so a large unrelated file list comes back — the same rebase-adjacent artifact noted throughout this PR's history), so per-file blob-SHA comparison was used instead of trusting the compare API's file list. That comparison shows this round changed docs/architecture.md, docs/problems/security-threat-model.md, internal/cli/run.go, internal/cli/steer.go, internal/cli/steer_test.go, internal/forge/forge.go, and internal/forge/github/github.go; the other 13 of 20 files are byte-identical to the prior round.
  • correctness (always full scope on re-review) traced the receipt/skip-check wiring, the job-token capture/mint-swap sequencing, and the settled-head rendering path across all 20 files and found no issues.
  • security (normal scope, dispatched because this round's delta touches token/auth-handling code in run.go/steer.go and the forge interface in forge.go/github.go) found the medium finding above.
  • style-conventions (trivial scope, no prior findings) found no issues.
  • docs-currency (dispatched because documentation files changed since the prior round) independently re-verified that the current wording in docs/ADRs/0120-*.md, docs/contributing/steering.md, and docs/architecture.md for the review-App identity match (login and the forge's AuthorIsApp verdict) and the job-token receipt mechanism matches the current code, and found no stale or inaccurate documentation.
  • cross-repo-contracts (dispatched because internal/forge/forge.go and internal/forge/github/github.go changed since the prior round) confirmed no forge.Client interface methods were added, removed, or had signatures changed this round, and re-confirmed checkHeadAlreadyReviewed still short-circuits before any forge call on GitLab, so PullRequestReview.CommitID not being populated there remains inert rather than silent.
  • intent-coherence was not dispatched: no issue is linked to this PR (verified via GraphQL closingIssuesReferences — empty), ADR 0120 is Accepted in this same PR and self-authorizes the change per this repo's ADR conventions, and this dimension had no prior findings to verify.
  • No protected paths (per the active REVIEW_PROTECTED_PATHS list) are touched — all 20 changed files are under docs/ or internal/.
  • No injection patterns or non-rendering Unicode were found in the PR title, body, or commit messages. Commits carry Signed-off-by trailers consistent with the repo's DCO policy for a human-directed, Claude-assisted session (Assisted-by: Claude).
  • Risk assessment: moderate (2/5). Tier 1 (62% weight, no linked issue) reflects a large diff (20 files, 3,098 lines, large blast radius) fully offset by zero protected/security-sensitive path hits by the path-pattern heuristic, no CI/dependency changes, a 0.30 test ratio, and an established contributor. Tier 2 (38% weight) is elevated by high recent churn, multi-author contention, and fix/revert history on long-lived hotspot files (run.go, forge.go). The composite rounds to 2 (moderate), consistent with every prior round's anchored score on this PR.

Next steps:

  • /fs-fix — agent addresses review findings automatically
  • /fs-fix <your instruction> — agent fixes with your specific guidance
  • Push commits directly — review re-runs automatically on push
  • /fs-fix-stop — disable automatic fix runs for this PR
Previous run (15)

Looks good to me

Previous run (16)

Review

Findings

Low

  • [incomplete-doc] docs/contributing/steering.md:428 — The second preflight skip is described as matching the review App on "its exact logins." appReviewedHeadSince (internal/cli/review_skip.go:126) also requires the forge's own App verdict (r.AuthorIsApp), which is an explicit test invariant (TestHeadAlreadyReviewed: "the review App's login without the forge's App verdict runs"). The paragraph understates the skip's identity criteria by naming only the login check.
    Remediation: Update the sentence to say the review App is matched on both its exact logins and the forge's App verdict (AuthorIsApp).

  • [incomplete-doc] docs/ADRs/0120-receipt-the-absorbed-update-under-the-job-token.md:97 — The same omission as in steering.md: the Decision section's description of the second skip ("the review App, matched on its exact logins, reviewed the current head...") does not mention that appReviewedHeadSince also requires the forge's App verdict (AuthorIsApp).
    Remediation: Add that the review App is matched on its exact logins and the forge's App verdict. This ADR is new in this PR, so a direct clarifying edit is appropriate (not a post-acceptance amendment).

  • [stale-doc] docs/architecture.md:332 — The ADR 0120 bullet (lines 332–339) describes only the job-token receipt skip for absorbed updates. It predates this round's addition of internal/cli/review_skip.go (the second, independent headAlreadyReviewed/runPreflightSkips skip for review duplicates) and was not revisited to mention it, leaving the architecture overview incomplete relative to ADR 0120's actual Decision.
    Remediation: Extend the ADR 0120 bullet to mention both preflight skips: the job-token receipt for absorbed updates, and the review-duplicate check for a head the review App already reviewed.

Notes

  • This is a re-review. The immediately-prior review round (head 6b9f9a77e9acae2653d41d370b37c83d159e65bc) found zero findings. GitHub's compare API reports diverged between that head and this one (a rebase artifact seen throughout this PR's long review history), so per-file blob-SHA comparison was used instead of trusting the compare API's file list. That comparison shows this round adds a new file (internal/cli/review_skip.go and its test), a new CommitID field on forge.PullRequestReview, and further changes to run.go, steer.go, steer_test.go, and three documentation files; the other 9 files are byte-identical to the prior round.
  • The delta is a genuine behavior addition, not a comment-only or doc-only change: internal/cli/review_skip.go adds a second, independent preflight skip (headAlreadyReviewed) for duplicate review-triggering events, evidenced by the review App's own prior review (matched on exact login, the forge's AuthorIsApp verdict, and a CommitID match against the current head) rather than a receipt.
  • correctness (always full scope on re-review) traced the new headAlreadyReviewed/runPreflightSkips mechanism, the job-token receipt/skip-check wiring, and the by-value credential-stripping mechanism, and found no issues.
  • security (normal scope, dispatched because this round's delta touches token/auth-handling code) independently traced the new skip's identity checks (App verdict + login + CommitID match), its fail-open behavior on API errors, and re-verified the previously-flagged stripOIDCEnv/strippedByValue residual; found no issues in the current code.
  • style-conventions (trivial scope, no prior findings) found no issues.
  • docs-currency (dispatched because documentation files changed since the prior round) found the three findings above; a challenger pass verified each against the cited code and documentation, kept all three as genuine but downgraded them from medium to low (the affected sentences are summaries rather than false claims of sufficiency, and the code already enforces the stricter checks the docs omit describing).
  • cross-repo-contracts (dispatched because internal/forge/forge.go's shared PullRequestReview struct changed for the first time in this PR's history) confirmed the new CommitID field is a backward-compatible, additive change with no interface-signature break. A second finding claiming GitLab's ListPullRequestReviews never populating CommitID would silently degrade the new skip on GitLab was removed after the challenger verified that checkHeadAlreadyReviewed explicitly short-circuits before any forge call when the platform is GitLab (internal/cli/review_skip.go) — the GitHub-only scope is coded and documented, not silent.
  • No linked issue (verified via GraphQL closingIssuesReferences — empty); ADR 0120 is Accepted in this same PR, which self-authorizes the change per this repo's ADR conventions, so intent-coherence was not dispatched (no prior findings to verify, and the "any non-trivial change" trigger does not apply on re-review without a linked issue).
  • No protected paths (per the active REVIEW_PROTECTED_PATHS list) are touched — all 20 changed files are under docs/ or internal/.
  • No injection patterns or non-rendering Unicode were found in the PR title, body, or commit messages. Commits carry Signed-off-by trailers consistent with the repo's DCO policy for a human-directed, Claude-assisted session (Assisted-by: Claude).
  • Risk assessment: moderate (2/5). Tier 1 (~1.75, 62% weight, no linked issue) reflects a large diff (20 files, 2,913 lines) fully offset by zero protected/security-sensitive path hits, no CI/dependency changes, a 0.30 test ratio, and an established contributor. Tier 2 (~3.29, 38% weight) is elevated by high churn, multi-author contention, and fix/revert history on long-lived hotspot files (run.go, forge.go). The composite (2.33) rounds to 2 (moderate), matching the prior anchored score even though this round is not a pure rebase like the immediately-prior one.

Next steps:

  • /fs-fix — agent addresses review findings automatically
  • /fs-fix <your instruction> — agent fixes with your specific guidance
  • Push commits directly — review re-runs automatically on push
  • /fs-fix-stop — disable automatic fix runs for this PR
Previous run (17)

Looks good to me

Previous run (18)

Looks good to me

Previous run (19)

Review

Findings

Low

  • [logic-error] internal/statuscomment/steermarker.go:156 — LatestSteerMarker matches comment authors with != (case-sensitive), while the same-identity refuse-to-skip path in steerAlreadyHandled uses strings.EqualFold because GitHub logins are case-insensitive. The skip check resolves the receipt login from GET /user (or the GraphQL viewer) and then requires an exact-case match against ListIssueComments' user.login. If those two endpoints ever disagree in case, a genuine job-token receipt is ignored — fail-open (the queued run redoes work) rather than a dropped update, which keeps this low. The PR already treats login case as a real evasion vector for the collision check (TestSteerAlreadyHandled_SameIdentityIsCaseInsensitive) but does not apply the same case-insensitive rule to the authorship match that actually honours a receipt.
    Remediation: Compare comment authors with strings.EqualFold(comments[i].Author, author) in LatestSteerMarker, and add a test where the resolved receipt login differs only in case from the comment's Author.

Next steps:

  • /fs-fix — agent addresses review findings automatically
  • /fs-fix <your instruction> — agent fixes with your specific guidance
  • Push commits directly — review re-runs automatically on push
  • /fs-fix-stop — disable automatic fix runs for this PR
Previous run (20)

Looks good to me

Previous run (21)

Looks good to me

Previous run (22)

Review

Findings

Medium

  • [stale-doc] docs/contributing/steering.md:354 — The newly-added "Who may write a receipt" section states that "a child script's environment drops any remaining entry whose value is the swapped-away token, so a caller cannot keep it reachable under a third name." This overstates coverage: only childScriptEnv (pre-flight, pre-script, post-script) applies the by-value strippedByValue strip. validation_loop.script composes its environment via stripOIDCEnv, which filters only denied keys by name and does not call strippedByValue — the exact residual gap the security dimension has flagged in every review round on this PR (see the credential-isolation finding below). The unqualified "a child script's environment" is inaccurate for that script class.
    Remediation: Qualify the claim to scope it to scripts whose environment is built via childScriptEnv (pre-flight, pre-script, post-script), and note that validation_loop.script currently relies on stripOIDCEnv, which strips only by name.

Low

  • [credential-isolation] internal/cli/run.go:2781 (also internal/cli/run.go:3857) — stripOIDCEnv (~3877-3892) still filters only harnessExpansionDenied names (oidcDenyKeys ∪ providerOnlyKeys) and never calls strippedByValue. Both validation_loop.script sites compose env as stripOIDCEnv(append(os.Environ(), validationEnv(...))). childScriptEnv (pre-script, post-script, validation_loop.preflight_check) does drop swapped-away values by value; validation_loop.script does not. Residual: a workflow- or runner_env-supplied third-name alias of the original job token remains reachable by a validation_loop.script. Exploiting it needs that alias plus a validation process willing to post as the job-token login, which sits inside ADR 0120's own accepted trust boundary (any job in the repository can already write a receipt under the same login), and the fail-open direction is unchanged (no alias costs one redundant run, not a silent skip). This is the same residual reported and re-confirmed unchanged in every prior review round on this PR; the new by-value stripping mechanism this PR adds (swappedAwayTokens/strippedByValue, wired into childScriptEnv and made nested-mint-safe via swappedHere/forgetSwappedAwayToken) is itself correct — it simply is not applied to stripOIDCEnv.
    Remediation: Apply strippedByValue inside stripOIDCEnv (or route validation env composition through childScriptEnv), so any host child process that inherits os.Environ() after a mint drops swapped-away token values, not only denied names.

  • [incorrect-doc] docs/ADRs/0120-receipt-the-absorbed-update-under-the-job-token.md:84 — The Decision section's parenthetical lists "the status comment, the sticky comment and the tracker comment bodies" as the paths on which agent-authored text is neutralized. NeutralizeMarkers is wired only into the sticky comment path (internal/sticky/sticky.go) and the tracker sticky comment path (internal/cli/issues.go). The terminal status comment does not call it: description is a fixed titleCase(agentName) string, the informational steer-marker copy is runner-built via SetSteerMarker/BuildSteerMarker, and the only script-originated field (detail) goes through the separate sanitizeDetail function, which escapes every < (blocking <!--) rather than NeutralizeMarkers. This is a wording imprecision rather than a missing control — the skip check still ignores App-authored markers regardless.
    Remediation: Correct the parenthetical to name only the sticky and tracker comment bodies, or clarify that the terminal status comment carries no agent-authored freeform body and instead sanitizes its bounded detail field via sanitizeDetail.

Notes

  • This is a re-review (round 12). GitHub's compare API reports diverged between the prior review's head (a4e072a1d1a06b3ed9718bdb2958722264c09fe9) and this head — the same rebase artifact noted in previous rounds, so per-file blob-SHA comparison was used instead of trusting the compare API's file list. That comparison shows docs/ADRs/0120-*.md, docs/architecture.md, docs/contributing/steering.md, docs/problems/security-threat-model.md, internal/cli/run.go, internal/cli/steer.go, and internal/cli/steer_test.go changed since the prior round; the other 7 files (internal/cli/issues.go, internal/cli/issues_test.go, internal/statuscomment/statuscomment.go, internal/statuscomment/steermarker.go, internal/statuscomment/steermarker_test.go, internal/sticky/sticky.go, internal/sticky/sticky_test.go) are byte-identical to the prior round.
  • The delta since the prior round is a genuine behavior addition, not a comment-only or doc-only change: the job-token-authenticated receipt/skip-check wiring landed in run.go (steerMarker capture, checkSteerAlreadyHandled call site before the start comment/pre-script, the postSteerReceipt defer), along with a new by-value credential-stripping mechanism (swappedAwayTokens/strippedByValue/forgetSwappedAwayToken) wired into childScriptEnv and mintAgentTokenAtLevel (now swaps both GH_TOKEN and GITHUB_TOKEN, nested-mint-safe).
  • correctness (always full scope on re-review) reviewed the new receipt/skip-check wiring, the by-value stripping mechanism, and the settled-SHA rendering path (unchanged since the immediately-prior round) and found no issues.
  • security (normal scope, re-verifying the prior credential-isolation finding) independently re-traced stripOIDCEnv, the nested-mint cleanup (swappedHere/forgetSwappedAwayToken), the skip-check identity/fail-open logic, steerReceiptsHonoured's provider-directory scan, and the marker-neutralization defenses. All are sound except the persistent stripOIDCEnv gap, which is unchanged.
  • style-conventions (trivial scope, no prior findings) found no issues.
  • docs-currency (re-dispatched because documentation files changed since the prior round) found the two documentation findings above, plus a below-threshold info-level finding (a missing table-of-contents entry for the new "The skip check" section in steering.md) that is not reported per the active severity threshold.
  • No documentation identifier renames/removals were found stale beyond the two findings above. No public API/CLI surface is touched, so cross-repo-contracts was not dispatched. No issue is linked to this PR (verified via GraphQL closingIssuesReferences — empty), and no code implementing issue-relevant claims exists to re-qualify intent-coherence, so it was not dispatched this round.
  • The challenger sub-agent reviewed all three findings above and kept each unchanged (no removals, no downgrades, no merges) — the credential-isolation finding is real but confined to ADR 0120's accepted trust boundary; the two doc findings are genuine imprecisions in newly-added documentation, not stylistic nits.
  • No protected paths (per the active REVIEW_PROTECTED_PATHS list) are touched — all 14 changed files are under docs/ or internal/.
  • No injection patterns or non-rendering Unicode were found in the PR title, body, or commit messages.
  • Risk assessment: moderate (2/5). Tier 1 signals are unchanged from the prior anchored assessment in bucket terms (14 files, 2295 lines, large blast radius, zero protected/security-sensitive path hits by the path-pattern heuristic, no CI/dependency changes, ~0.29 test ratio, known non-first-time author). Tier 2 churn is elevated on run.go, docs/architecture.md, and docs/problems/security-threat-model.md (very high commit/fix-revert frequency) but pulled down by several brand-new files with no git history, and the newly-landed job-token receipt/credential-stripping logic is captured by run.go's already-elevated churn score rather than by the path-pattern security heuristic. The composite continues to round to 2 (moderate).

Next steps:

  • /fs-fix — agent addresses review findings automatically
  • /fs-fix <your instruction> — agent fixes with your specific guidance
  • Push commits directly — review re-runs automatically on push
  • /fs-fix-stop — disable automatic fix runs for this PR

fullsend-ai-review[bot]

This comment was marked as outdated.

@fullsend-ai-review fullsend-ai-review Bot added security Security threat model and related concerns component/runner Agent runner behavior and lifecycle labels Sep 18, 2026
@fullsend-ai-review

fullsend-ai-review Bot commented Sep 18, 2026 •

Copy link
Copy Markdown

🤖 Review · ❌ Terminated · Started 6:07 PM UTC · Ended 6:36 PM UTC

Commit: f28d843 · View workflow run →

@github-actions

github-actions Bot commented Sep 18, 2026 •

Copy link
Copy Markdown

Site preview

Preview: https://a69822c6-site.fullsend-ai.workers.dev

Commit: db885bf294657aa2ed417943c1ed99c51e55873c

fullsend-ai-review[bot]

This comment was marked as outdated.

fullsend-ai-review[bot]

This comment was marked as outdated.

fullsend-ai-review[bot]

This comment was marked as outdated.

@fullsend-ai-review

fullsend-ai-review Bot commented Sep 25, 2026 •

Copy link
Copy Markdown

🤖 Finished Review · ✅ Success · Started 9:44 PM UTC · Completed 10:21 PM UTC

Commit: 8b4ba99 · View workflow run →

Runtime: pi · Model: sonnet → claude-sonnet-5 · Effort: high · Cost: $27.62

fullsend-ai-review[bot]

This comment was marked as outdated.

@fullsend-ai-review

fullsend-ai-review Bot commented Sep 26, 2026 •

Copy link
Copy Markdown

🤖 Finished Review · ✅ Success · Started 4:02 AM UTC · Completed 4:26 AM UTC

Commit: d1e26ad · View workflow run →

Runtime: pi · Model: sonnet → claude-sonnet-5 · Effort: high · Cost: $12.01

fullsend-ai-review[bot]

This comment was marked as outdated.

@fullsend-ai-review

fullsend-ai-review Bot commented Sep 26, 2026 •

Copy link
Copy Markdown

🤖 Finished Review · ✅ Success · Started 2:31 PM UTC · Completed 3:08 PM UTC

Commit: eb62c52 · View workflow run →

Runtime: pi · Model: sonnet → claude-sonnet-5 · Effort: high · Cost: $18.73

fullsend-ai-review[bot]

This comment was marked as outdated.

@fullsend-ai-review

fullsend-ai-review Bot commented Sep 28, 2026 •

Copy link
Copy Markdown

🤖 Finished Review · ✅ Success · Started 8:22 PM UTC · Completed 8:46 PM UTC

Commit: 8d0f4dd · View workflow run →

Runtime: pi · Model: sonnet → claude-sonnet-5 · Effort: high · Cost: $13.38

fullsend-ai-review[bot]

This comment was marked as outdated.

@fullsend-ai-review

fullsend-ai-review Bot commented Sep 28, 2026 •

Copy link
Copy Markdown

🤖 Finished Review · ✅ Success · Started 10:17 PM UTC · Completed 10:38 PM UTC

Commit: 7a25772 · View workflow run →

Runtime: pi · Model: sonnet → claude-sonnet-5 · Effort: high · Cost: $11.49

fullsend-ai-review[bot]

This comment was marked as outdated.

@fullsend-ai-review

fullsend-ai-review Bot commented Sep 28, 2026 •

Copy link
Copy Markdown

🤖 Finished Review · ✅ Success · Started 11:28 PM UTC · Completed 12:01 AM UTC

Commit: 7632158 · View workflow run →

Runtime: pi · Model: sonnet → claude-sonnet-5 · Effort: high · Cost: $14.61

fullsend-ai-review[bot]

This comment was marked as outdated.

@fullsend-ai-review

fullsend-ai-review Bot commented Sep 30, 2026 •

Copy link
Copy Markdown

🤖 Finished Review · ✅ Success · Started 12:33 AM UTC · Completed 12:57 AM UTC

Commit: 0cdccc0 · View workflow run →

Runtime: pi · Model: sonnet → claude-sonnet-5 · Effort: high · Cost: $12.69

fullsend-ai-review[bot]

This comment was marked as outdated.

@fullsend-ai-review

fullsend-ai-review Bot commented Sep 30, 2026 •

Copy link
Copy Markdown

🤖 Finished Review · ✅ Success · Started 4:16 PM UTC · Completed 4:44 PM UTC

Commit: c2c2ac0 · View workflow run →

Runtime: pi · Model: sonnet → claude-sonnet-5 · Effort: high · Cost: $13.80

fullsend-ai-review[bot]

This comment was marked as outdated.

@fullsend-ai-review

fullsend-ai-review Bot commented Sep 30, 2026 •

Copy link
Copy Markdown

🤖 Finished Review · ✅ Success · Started 7:26 PM UTC · Completed 7:41 PM UTC

Commit: ab55ac8 · View workflow run →

Runtime: pi · Model: sonnet → claude-sonnet-5 · Effort: high · Cost: $5.81

fullsend-ai-review[bot]

This comment was marked as outdated.

@fullsend-ai-review

fullsend-ai-review Bot commented Sep 30, 2026 •

Copy link
Copy Markdown

🤖 Finished Review · ✅ Success · Started 8:38 PM UTC · Completed 8:56 PM UTC

Commit: 738918a · View workflow run →

Runtime: pi · Model: sonnet → claude-sonnet-5 · Effort: high · Cost: $9.58

fullsend-ai-review[bot]

This comment was marked as outdated.

A run in flight absorbs an update and the run queued behind it does the work
again, so steering costs more than preserving alone: two reviews of one head
where preserving alone produces one.

After a successful run that absorbed at least one steer, the runner posts a
receipt naming the follow-up runs it consumed. A queued run reads the latest
receipt in its pre-flight, before the start comment and before the pre-script,
and exits 0 without starting the agent when it finds its own run id.

The receipt's author is the whole of the authentication, and it is the GitHub
Actions job token's. Two conditions are enforced rather than assumed: minting
must actually have swapped the credential, since otherwise it stays in the
environment a post-script inherits; and the receipt login must differ from the
role's, since the action's github_token is a caller-supplied input that can
resolve to the identity the agent posts under.

No receipt is honoured while any provider definition in .fullsend/providers/
expands GH_WORKFLOW_TOKEN, whichever harness uses it: that hands the job token
to a sandbox, where the agent can recover it and forge one (ADR 0114).

A queued review also skips when the review App already reviewed the
pull request's current head after the queued run was created. Two events
on one head route two reviews, and the run in flight writes no receipt
for a run it rejects as not fresh. A human /fs-review, a manual re-run,
an unreadable event and every error run the review, steering or not.

Only an outright success writes a receipt, once per run, naming what the
iteration whose output shipped absorbed. Everything fails open: a false
"already handled" drops work, a false "not handled" costs one run.

The terminal status comment keeps an informational copy of the marker that the
skip check does not honour, and agent-authored text is neutralized before it
reaches that comment.

Assisted-by: Claude
Signed-off-by: Wayne Sun <gsun@redhat.com>
steering.md gains the receipt's own sections: what the runner posts, who may
write one and what that author proves, and which direction each failure takes.

architecture.md records the decision beside the rest of the steering chain, and
the threat model's coalescing mitigation names the receipt the queued run exits
on.

Assisted-by: Claude
Signed-off-by: Wayne Sun <gsun@redhat.com>
@fullsend-ai-review

fullsend-ai-review Bot commented Sep 30, 2026 •

Copy link
Copy Markdown

🤖 Finished Review · ✅ Success · Started 9:20 PM UTC · Completed 9:36 PM UTC

Commit: db885bf · View workflow run →

Runtime: pi · Model: sonnet → claude-sonnet-5 · Effort: high · Cost: $4.38

@fullsend-ai-review fullsend-ai-review Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Note: The following review comments could not be posted on the diff (GitHub returned 422) and are included here instead:

  • docs/contributing/steering.md (file-level): Line 100 · [high] incorrect-doc

Lines 100–101 of the new head-move paragraph claim that when a move is "cut off" by "the steer budget," it is not taken as told: lastHead stays put and the next steer reports the same move again. That is not what the watcher does, and the sentence sits immediately after the inner head-move comparison cuts ("a file list longer than the head-move budget"; patches bounded with the cut stated), so a reader applies the pinned-head rule to the wrong budget. Independently re-checked against the PR-base internal/steerwatch sources (not part of this PR's diff, but the behavior this new prose describes): maxHeadMoveBytes (6 KiB, delta.go) is the inner compare cap; maxDeltaBytes (16 KiB) is the outer envelope shared with amendments/comments. headMoveContext treats a listing that exceeds maxHeadMoveBytes the same as a force-push, a 300-file cap, or a forge error: it returns a complete "could not be read / read the pull request yourself" item (the listing-overflow reason even says "longer than the steer budget"). Patch overflow still delivers the full file listing plus a stated cut. In both inner-budget cases, buildText leaves headClipped=false, and markSteered runs if d.headMoved && !w.headClipped { w.lastHead = d.newHead } — the head still advances. TestHeadBaselineAdvancesOnDelivery uses the same unreadable/no-compare fixture as the force-push case and asserts the baseline advances, so the next delta does not repeat the move. lastHead is held only when the outer envelope budget (maxDeltaBytes) clips the entire head-move item out of the message (headClipped=true), which is what TestHeadBaselineHoldsWhenTheListingWasClipped covers — that scenario is driven by amendments exhausting the envelope, not by the file list exceeding maxHeadMoveBytes. Believing the current sentence would lead an engineer or on-call reader to expect a retry of an unreadable/truncated compare that the watcher will never send. This finding was independently identified by both the correctness and docs-currency review dimensions and confirmed by an adversarial re-check against the cited tests.

Suggested fix: Split the two budgets in the prose and do not call maxHeadMoveBytes "the steer budget" in the same sentence as the pinned-head rule. (1) An unreadable compare — force-push, listing at the 300-file cap, file list longer than maxHeadMoveBytes, or a forge error — is delivered as "could not be read"; lastHead advances and the next steer does not repeat the move. A listing or patches that exceed the head-move budget is still delivered (unreadable notice, or partial patches with the cut stated) and advances the head baseline. (2) Only when maxDeltaBytes clips the head-move item out of the envelope — typically because amendments exhausted the room — is the move not taken as told, lastHead stays, and the next steer reports it again.

@fullsend-ai-review fullsend-ai-review Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

See the review comment for full details.

@waynesun09

Copy link
Copy Markdown
Member Author

Superseded by #9031; the steer design was reworked on top of ADRs 0133/0141/0144/0151.

This branch had an error being deployed

1 failed and 1 active deployments
site-preview — db885bf2 Deployed Sep 30, 2026 by github-actions[bot]
dev — db885bf2 Deployed Sep 30, 2026 by waynesun09 via behaviour #14720
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

component/runner Agent runner behavior and lifecycle fullsend-no-fix Skip bot-triggered fix agent runs security Security threat model and related concerns type/adr

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants