Skip to content

fix(chat): bound the $-menu skills fetch so a slow gateway fails visibly - #7062

Merged
iamwhatever merged 1 commit into
kirodotdev:mainfrom
rnoack1:fix/skills-fetch-timeout
Sep 1, 2026
Merged

iamwhatever merged 1 commit into
kirodotdev:mainfrom
rnoack1:fix/skills-fetch-timeout

Conversation

@rnoack1

@rnoack1 rnoack1 commented Aug 30, 2026 •

Copy link
Copy Markdown
Contributor

Problem / Motivation

SkillPickerMenu computes const loading = isLoading && open, and react-query's isLoading clears only when the query resolves or rejects. api.skills passed no AbortSignal, so a response that never arrives never settles, and the $-trigger menu shows Loading skills… indefinitely — indistinguishable from a hang.

skills was the outlier in its own file. Its siblings chatSlotDetail, sendChat and fileSearch all already accept an AbortSignal.

The latency that exposes it is real and measured. GET /api/skills on one host inside twenty minutes:

observation elapsed payload
1 0.62s 329,860 bytes
2 9.76s 329,860 bytes
3 41.41s 329,860 bytes
4 168.71s 329,860 bytes

Byte-identical each time, so the variance is not the skills scan (~0.6s) — it is event-loop contention in the gateway. That cause is being addressed separately by #7031 (a 3s server-side memo for this endpoint), which reduces exposure but does not fix this: any future slow path still spins forever, because the client has no deadline at all. This PR is the client-side half and does not overlap #7031.

Why it matters

A spinner that never resolves is worse than an error. The user cannot tell "slow" from "broken", so the only recovery is a reload — and the menu is on the composer's typing path, so it is hit often.

There is a second, sharper consequence. The menu's releaseKeysWhenEmpty gate is
!isFetching && (data !== undefined || isError) && matched.length === 0. While the query is pending it is false, which is correct — it deliberately swallows Enter so a draft mid-$token is not sent by accident. But an unbounded pending state means Enter is swallowed forever: the composer cannot send at all until the page is reloaded. Verified in source rather than assumed: that gate already admits isError, so a settled rejection is enough to release the keys, and an existing test (after the skills fetch settles in an ERROR, Enter is released) pins it. A timeout therefore needs no downstream change — it just has to make the query settle.

What changed

Four small pieces.

  1. website/src/lib/withDeadline.ts (new, 40 lines) — runs an attempt under a deadline, relays the caller's signal, and releases both the timer and the relay listener on settle.

  2. website/src/api/client.ts — skills gains an optional trailing signal (threaded through the shared get() helper, also a new optional trailing parameter, so every other caller is unaffected) and the deadline is applied here, once:

skills: (sessionKey?: string, agent?: string, signal?: AbortSignal) =>
  withDeadline(SKILLS_TIMEOUT_MS, signal, s =>
    get('/api/skills' + (agent ? '?agent=' + encodeURIComponent(agent) : ''),
        sessionKey, s).then(j)),

Each of the three queryFns that had been wrapping the call individually now just passes react-query's signal straight through — ({ signal }) => api.skills(slotKey, agent, signal) — and the withDeadline/SKILLS_TIMEOUT_MS imports are gone from all three components.

  1. The deadline is not retried — bound once, app-wide. api/queryClient.ts gains isDeadlineError and folds it into the existing default retryPolicy as a first clause. Without it the default retries any non-throttle failure once, so a 15s bound settled at ~31s with its backoff — and because isLoading/releaseKeysWhenEmpty only settle when retries exhaust, the composer stayed un-sendable for twice the advertised window.

    An earlier revision threaded retry: per query at three sites. That repeated, for retry, the same weakness this PR argues against for the deadline: react-query dedupes on the key, so a per-initiator rule is only as strong as the weakest initiator sharing that key. Binding it in the default policy every query inherits closes all of them and is strictly smaller — three imports and three option lines deleted. It stays narrower than retry: false: an ordinary failure keeps its single retry and a throttle keeps the full 429 ladder, both pinned by assertion. A TimeoutError only ever originates from lib/withDeadline, so no other query's behaviour changes today.

  2. A failed load no longer renders as an empty catalog — a new isError branch selects skills_load_failed{,_enter_sends,_ctrl_enter_sends} instead of the no_matching_skills* copy, with all 14 catalogs updated (en-XA regenerated via npm run i18n:pseudo). The key-release behaviour is unchanged: returning Enter to the composer was already correct.

Why the deadline binds inside api.skills rather than at each initiator

An earlier revision of this PR threaded the deadline at three call sites, and this description argued for that. Both were wrong, and the reason is worth stating because it is the whole shape of the fix.

React-query dedupes on the query key, so per-initiator binding is only as strong as the weakest initiator of that key. Measured at source, there are two shared keys and six non-test call sites:

query key initiators
['skills', slot, project, agent] ChatInput.tsx:1337 (focus prefetch), SkillPickerMenu.tsx:97
['skills'] HookSkillsSelect.tsx:30, skillsProvider.ts:206, SkillsTab.tsx:90
['skills-catalog'] AgentSkillsEditor.tsx:56

Whichever initiator wins the race is the one that actually fetches; the others reuse its promise and never run their own queryFn. So threading three of six left two live holes — the $-menu could dedupe onto ChatInput's prefetch, and the command palette onto SkillsTab or HookSkillsSelect — and any initiator added later would silently reopen one. Wrapping once inside api.skills makes the hole structurally unreachable: every one of the six goes through the same bounded function, including the three (AgentSkillsEditor, HookSkillsSelect, SkillsTab) that this PR previously declared unbounded-and-deferred. It is also strictly smaller — three wraps and four import lines deleted.

Measured at source, there are six react-query initiators of api.skills, not five — the review notes name SkillsTab and AgentSkillsEditor as the unfixed pair but miss HookSkillsSelect.tsx:32, which also uses the bare ['skills'] key. So per-site threading had left three holes, two of them on the key the command palette dedupes onto. Folding the rule into the default policy closes all three, and the retry test carries one case per initiator.

One correction to the First Principles note, verified at source: its client.ts:2770,2862,3091 and SkillPickerMenu.tsx:158 coordinates have drifted by a rebase (the siblings are now at :2772/:2864/:3093 and the isError gate at :162). Both underlying claims hold — chatSlotDetail/sendChat/fileSearch do take an AbortSignal, and the isError release gate does exist.

Both sibling pickers are untouched, each deferred for a named reason:

  • FilePickerMenu.tsx:111 — #7068's work; touching it here would collide.
  • SlashCommandMenu.tsx:189 — carries the identical Enter-swallowing gate (!isFetching && filtered.length === 0) over api.slashCommands() (client.ts:2396, which takes no signal), so a wedged fetch swallows Enter on an unmatched /xyz. Same root cause, different endpoint and different cache key, so it needs its own bound, its own tests and its own measured latency evidence — none of which this diff carries. Deferred to a follow-up PR of its own, in the same shape as this one; widening the diff to a third picker now would invite fresh findings on a change that is otherwise ready.

Why not AbortSignal.any([signal, AbortSignal.timeout(N)])

That is the direct expression of this and was the first implementation. Two things pushed it out, one of them measured:

  • AbortSignal.timeout exposes no handle, so its timer cannot be cancelled. It therefore leaves a live 15s timer behind every successful menu open. That is a leak on its own terms, and it is observable: it stalled the teardown of an unrelated suite (ChatInput.skillTrigger.test.tsx) by 10s, because the shared test setup drains the DOM task queue before shutting its mock server down — 3.69s baseline to a 10,283ms suite failure. An AbortController plus an explicit clearTimeout on settle has neither problem.
  • Browser baseline. The repo declares no browserslist and no vite/esbuild target override; tsconfig.app.json is target: ES2020, lib: ["ES2023", "DOM", "DOM.Iterable"]. AbortSignal.timeout already ships in-tree (src/pages/DevFleetPage.tsx, twice), floor Chrome 103 / Firefox 100 / Safari 16. AbortSignal.any has no existing use and a materially higher floor: Chrome 116 / Firefox 124 / Safari 17.4. A missing any throws synchronously inside queryFn, which react-query catches — turning "slow sometimes" into "the menu is empty every time it opens" on an older engine. The AbortController form needs no feature detection, so the question does not arise.

Why the abort reason is an Error, not a DOMException

The timeout reason would naturally be new DOMException('…', 'TimeoutError') — that is what AbortSignal.timeout itself produces. Two i18n gates in Frontend Lint & Type Check refuse it, and both are zero-tolerance on added lines with no ceiling to raise:

  • check-i18n-strings.mjs drives a second eslint pass whose callees.exclude carries '^(Type)?Error$' under the heading "Diagnostics and dev-only output" — but not DOMException, so both the message and the 'TimeoutError' name argument were reported (2 findings on one line). Note it runs with allowInlineConfig: false, so an eslint-disable comment cannot dispose of this.
  • check-unit-literals.mjs is a separate TypeScript-AST scan that never consults eslint's exclusions, and flagged ${ms}ms as a number+unit literal on its own. Its documented dispositions are the src/i18n/format.ts helpers or a ROUND_TRIP parser entry — neither applies to an internal abort reason that nothing renders and nothing parses.

So the reason is built with Error (the exemption the repo already grants diagnostics) and the interpolated duration is dropped rather than reformatted — importing an i18n formatter into a leaf utility to translate a string no one reads would be the wrong trade. .name is still 'TimeoutError', which is what the tests assert and what the web standard uses.

Choice of N = 15s

  • Above the 9.76s observation, which did complete. This direction matters more than it looks: a spurious timeout settles the menu empty, which (per the gate above) hands Enter back to the composer and can send a draft the user was still completing. Failing a recoverable fetch is worse than a slow list.
  • Below the 41.41s and 168.71s observations, which it converts into a visible settled error.
  • ~24x the healthy 0.62s, and far past any plausible willingness to wait on an autocomplete.

Both bounds are pinned by assertion (> 9_760, < 41_410), so moving the constant outside the measured window fails the suite rather than drifting silently.

Noted, not changed

skillsCacheStaleTime() in website/src/lib/skillsCache.ts (a file this PR no longer touches) returns 0 when project is undefined, so on a project-less slot every reopen refetches — which is what makes this endpoint's latency user-visible as often as it is. I left it alone on purpose: the 0 is deliberate and load-bearing. Its own comment explains that without project identity the query key cannot observe a same-slot project switch, so caching would serve another project's catalog. That is a correctness trade, not an oversight, and narrowing it is a separate change with a separate argument.

Tests

The deadline is now a client-layer guarantee, so it is pinned at that layer: website/src/test/apiSkillsDeadline.test.ts (new) drives the real api.skills against a stubbed fetch that only settles on abort. Its first case passes no signal at all — the exact shape AgentSkillsEditor, HookSkillsSelect and SkillsTab use — which is what proves those three are bounded now. The component suites keep what the components actually owe: passing react-query's signal through, rendering a settled failure as a failure, and — under the app's own default retry policy rather than a retry: false client — running the fetch exactly once.

Three existing arity assertions in SkillPickerMenu.test.tsx were updated for the new third argument.

Counts

suite result
apiSkillsDeadline.test.ts 8 passed
skillsRetryPolicy.test.ts 11 passed
withDeadline.test.ts 9 passed
SkillPickerMenu.timeout.test.tsx 4 passed
SkillPickerMenu.dedupe.test.tsx 5 passed
ChatInput.skillsPrefetchDeadline.test.tsx 2 passed
SkillPickerMenu.test.tsx 39 passed
ApiClient.coverage.test.tsx 681 passed
full vitest run src/ 1665 files, 26416 passed, 3 skipped, exit 0
npx tsc -b 0 errors
npx eslint src/ --max-warnings 659 658 warnings, 0 errors (the base measures 658 too, so this diff adds none)
npx jscpd . exit 0
node scripts/i18n-check.mjs 19 checks · PASS

One upstream baseline refresh, not mine

Rebasing onto bb3d4943952a brought in 20b3710c054a, after which test/test_agent_sdk_boundary.py::test_every_recorded_violation_still_exists fails with {'src/kiro_crew/subagent.py': (9, 8)}: the baseline records 9 imports for that file while the tree has 8. Applied the refresh the gate itself prescribes (--update-baseline). The rule is unchanged and no exemption was added.

Narrowed to exactly the one prescribed line: the script also regenerates its own header comment, which would have rewritten an unrelated line of prose, so that line is left at upstream's text. The committed diff is the single count line and nothing else; the boundary suite then passes 25/25.

Negative controls

A passing test proves nothing on its own, so each claim was checked by reverting the thing it asserts.

# reverted expected to fail actual
1 the withDeadline wrap inside api.skills the deadline tests 3 of 5 failed, each hanging the full 15s test timeout — which is the defect. The signal-relay and healthy-path cases correctly still passed, so the control discriminates
2 clearTimeout(timer) removed from release() the 3 timer-release tests 3 failed
3 the outer.aborted up-front check removed the already-aborted test 1 failed, after sitting out the full deadline — the exact cost the check exists to avoid
4 the isError copy branch removed the two error-copy tests 2 failed; the genuinely-empty test still passed, which is the point — the branch must key on the error, not on emptiness
5 the isDeadlineError clause removed from the default retryPolicy every initiator case 7 failed — all six initiators ran the fetch twice, which is the ~31s wait. The throttle-ladder, ordinary-retry and type-discrimination cases correctly still passed, so the control discriminates rather than failing wholesale
6 the clause widened to a blanket retry: false the narrowing cases 2 failed — an ordinary failure lost its single retry and a 429 lost its ladder, so the narrowing cannot silently broaden

A harness collision, and where the tolerance belongs

Moving the wrap into api.skills made an existing test fail — ApiClient.coverage.test.tsx's "every api method issues one well-formed /api request", which drives every method with uniform positional junk ('sw-1'…'sw-4'). The other signal-taking methods survive that because they only ever forward the signal to fetch, which the mock ignores; withDeadline was the first code to actually use it, so a string in the signal position threw TypeError: outer?.addEventListener is not a function.

An earlier revision absorbed this with a typeof outer?.addEventListener === 'function' guard in withDeadline. That was the wrong layer: production has zero non-signal producers across all six call sites, so the guard defended only against the harness. The guard is gone, and the tolerance now sits where the non-signal actually originates — skills joins the harness's own HAND_TESTED escape hatch (alongside the four methods already there for needing real fixtures), and that sweep's URL assertions are replicated verbatim against api.skills in apiSkillsDeadline.test.ts, so excluding it costs no coverage. Verified by the full suite passing with the guard removed: had anything outside the harness depended on it, that would have shown up here.

Why no screenshot: No layout, theme, or component change — no new markup and no styling. The change is behavioural (a stuck Loading skills… now settles) plus one string swap in the picker's existing role="status" empty-state slot: No matching skills — Enter sends the message becomes Couldn't load skills — Enter sends the message on the error path only. Both the old and new strings are in the diff verbatim, in the same element, so the visual result is fully judgeable from the diff and the catalog entries; a screenshot would show pre-existing chrome around one line of text.

@rnoack1
rnoack1 requested review from a team and CrysisDeu August 30, 2026 17:24
@github-actions github-actions Bot added fork Pull request from a fork (external contributor) readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running and removed readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running labels Aug 30, 2026
@rnoack1
rnoack1 force-pushed the fix/skills-fetch-timeout branch from 3ae889e to 885e622 Compare August 30, 2026 17:59
@github-actions github-actions Bot added readiness: checking Automated validation is still running and removed readiness: action required A blocking check or review needs attention labels Aug 30, 2026
@github-actions

github-actions Bot commented Aug 30, 2026 •

Copy link
Copy Markdown
Contributor

GPT 5.6 Review (fork) — ✅ no blocking findings

Reviewed dc1c01a985404230ba1aa3d1aa54374e2fdc4831 via the fork AI-review pipeline; updated in place on each push.

Review details

No findings.
[GPT-REVIEWED] dc1c01a

@github-actions

github-actions Bot commented Aug 30, 2026 •

Copy link
Copy Markdown
Contributor

Design Review (Fable 5, fork) — ✅ PASS

Design-level review of dc1c01a985404230ba1aa3d1aa54374e2fdc4831 via the fork AI-review pipeline — updated in place on each push. A BLOCK verdict blocks PR readiness; PASS/CONCERNS are advisory.

The patch is fully covered: client-layer deadline (withDeadline + api.skills), app-wide no-retry-on-deadline clause, error copy across 13 locale files, and an extensive test suite with negative controls. I verified the base file claims (releaseKeysWhenEmpty gate admits isError at SkillPickerMenu.tsx:158, AbortSignal.timeout uses in DevFleetPage.tsx are raw fetches outside react-query, so the new retry clause changes no existing query). The design argument — bind once in the client because react-query dedupes on the key — is correct and the diff matches the description.

Design-Verdict: PASS

Bounding once inside api.skills is the right layer — dedupe makes per-initiator deadlines structurally unsound — and the scope is proportionate.

Suggestions

  • isDeadlineError keys on the generic .name === 'TimeoutError', so any future browser-native or third-party timeout in a queryFn silently loses its retry; branding the reason in timeoutReason() (own marker property checked by isDeadlineError) would confine the app-wide no-retry rule to exactly the deadlines this code sets.

[DESIGN-REVIEWED] dc1c01a

@github-actions

github-actions Bot commented Aug 30, 2026 •

Copy link
Copy Markdown
Contributor

UX Review (Fable 5, fork) — ✅ PASS

UX-level review of dc1c01a985404230ba1aa3d1aa54374e2fdc4831 via the fork AI-review pipeline — updated in place on each push. A BLOCK verdict blocks PR readiness; PASS/CONCERNS are advisory.

All evidence reviewed: the patch, the SkillPickerMenu base component, and the sibling consumers of api.skills (SkillsTab, HookSkillsSelect). The changes bound a previously infinite "Loading skills…" hang at 15s, stop react-query from doubling that wait with a retry, and replace the false "No matching skills" claim on a failed fetch with "Couldn't load skills" — with the Enter/Ctrl+Enter release announcement preserved, the copy pattern matching the existing sibling strings exactly, and all 12 locales plus the pseudo-locale updated in the same diff. Reopening the picker refetches an errored query, so recovery exists; the surfaces without changed lines (SkillsTab) render the same pixels before and after, so no new regression. Nothing rose past the kill-filter.

UX-Verdict: PASS

A hang becomes a bounded, truthfully-worded failure that hands Enter back — copy, locales, and keyboard behavior all match the picker's established pattern.

[UX-REVIEWED] dc1c01a

@github-actions

github-actions Bot commented Aug 30, 2026 •

Copy link
Copy Markdown
Contributor

Opus 4.8 Review (fork) — ✅ no blocking findings

Reviewed dc1c01a985404230ba1aa3d1aa54374e2fdc4831 via the fork AI-review pipeline; updated in place on each push.

Review details

The candidate list is empty (the discovery pass found nothing), so there is nothing to falsify in Step 1. I've independently verified the load-bearing logic myself:

  • withDeadline — timer/listener cleanup on async settle, sync throw, and already-aborted outer signal; aborts with an Error (name TimeoutError) so fetch rejects with that reason.
  • isDeadlineError/retryPolicy — keys on name === 'TimeoutError', correctly nested so throttle (429) and single-retry behaviour are preserved; a deadline never retries.
  • SkillPickerMenu error branch — loadFailed = isError && items.length === 0 takes precedence over mappedEmpty; a cached-then-refetch-error keeps items and shows results; releaseKeysWhenEmpty admits isError, so Enter is released rather than swallowed.
  • Signal threading through ChatInput prefetch and skillsProvider matches the menu's query key; the deadline binds in the client so dedupe can't leave an unbounded winner.

No grounded defect (a/b/c at 80+) survives, and none is newly derivable. This is a successful clean review.

No findings.

[OPUS-REVIEWED] dc1c01a

@github-actions

github-actions Bot commented Aug 30, 2026 •

Copy link
Copy Markdown
Contributor

First Principles Review (Fable 5, fork) — ✅ PASS

Premise-level review of dc1c01a985404230ba1aa3d1aa54374e2fdc4831 via the fork AI-review pipeline — why this exists and whether the shipped surface is the smallest honest version. Updated in place on each push. A BLOCK verdict blocks PR readiness; PASS/CONCERNS are advisory.

All description claims check out against the base tree: the six api.skills initiators (I count exactly 6 non-test sites), the isError release gate at SkillPickerMenu.tsx:158, the signal-taking siblings at client.ts:2756/2848/3077, the base retryPolicy, and the identical unfixed Enter-swallow gate in SlashCommandMenu.tsx:189. No existing deadline helper exists in website/src (the only prior art, AbortSignal.timeout at DevFleetPage.tsx:124, cannot relay a caller signal or release its timer).

First-Principles-Verdict: PASS

A measured defect fixed at the mechanism level, the true cause named and handled elsewhere, and every rider serves the same "fail visibly" job.

What this change ships

Intent: stop the $-skills menu spinning forever (and swallowing Enter) on a slow gateway — a FIX.

  1. Skills fetch gives up after 15s instead of spinning forever — justified (measured latency table; cause owned by perf(skills): memoise the skills catalog behind GET /api/skills #7031)
  2. Bound lives in the client, so all 6 initiators inherit it — justified (6 counted: grep api.skills(, non-test)
  3. A self-set deadline is never retried, app-wide default — justified; declared (retry doubled the bound to ~31s)
  4. Failure reads "Couldn't load skills", not the false "No matching skills" (14 locales) — justified; the title's "fails visibly"
  5. get() gains an optional AbortSignal — justified; matches siblings at client.ts:2756/2848/3077 (verified)
  6. Composer Enter released on settle — pre-existing gate (SkillPickerMenu.tsx:158), correctly not re-shipped

Watch

  • isDeadlineError matches on name === 'TimeoutError', and that name already exists in the tree outside withDeadline (AbortSignal.timeout, DevFleetPage.tsx:124 — imperative fetch, not a query, so the "no other query changes today" claim holds today); any future AbortSignal.timeout inside a queryFn silently loses its retry under the app-wide clause.
  • Two sibling pickers carry the same root cause and are deferred with named reasons (SlashCommandMenu.tsx:189 verified identical gate over signal-less api.slashCommands; FilePickerMenu → fix(chat): bound the @-menu file-search fetch so a slow gateway fails visibly #7068) — accepted-and-deferred, declared in the description.

[FIRST-PRINCIPLES-REVIEWED] dc1c01a

@github-actions github-actions Bot added readiness: passed Eligible automated validation passed for the current revision and removed readiness: checking Automated validation is still running labels Aug 30, 2026
@rnoack1
rnoack1 force-pushed the fix/skills-fetch-timeout branch from 885e622 to d9acfe0 Compare August 30, 2026 19:29
@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running and removed readiness: passed Eligible automated validation passed for the current revision readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running labels Aug 30, 2026
@rnoack1
rnoack1 force-pushed the fix/skills-fetch-timeout branch from d9acfe0 to 45504a5 Compare August 30, 2026 20:12
@github-actions github-actions Bot added readiness: checking Automated validation is still running and removed readiness: action required A blocking check or review needs attention labels Aug 30, 2026
@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running readiness: passed Eligible automated validation passed for the current revision and removed readiness: passed Eligible automated validation passed for the current revision readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running labels Aug 30, 2026
@rnoack1
rnoack1 force-pushed the fix/skills-fetch-timeout branch from 0512acf to 645b96f Compare August 30, 2026 23:21
@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running and removed readiness: passed Eligible automated validation passed for the current revision readiness: action required A blocking check or review needs attention labels Aug 30, 2026
@github-actions github-actions Bot added readiness: passed Eligible automated validation passed for the current revision and removed readiness: checking Automated validation is still running labels Aug 31, 2026
@rnoack1
rnoack1 force-pushed the fix/skills-fetch-timeout branch from 645b96f to 1600b11 Compare August 31, 2026 01:12
@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention and removed readiness: passed Eligible automated validation passed for the current revision labels Aug 31, 2026
Give api.skills an AbortSignal and wrap the SkillPickerMenu queryFn in a 15s
deadline, so an unsettled fetch stops showing "Loading skills…" forever.
@rnoack1
rnoack1 force-pushed the fix/skills-fetch-timeout branch from 1600b11 to dc1c01a Compare August 31, 2026 03:32
@github-actions github-actions Bot added readiness: checking Automated validation is still running readiness: passed Eligible automated validation passed for the current revision and removed readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running labels Aug 31, 2026
@iamwhatever
iamwhatever merged commit 62c20a1 into kirodotdev:main Sep 1, 2026
72 checks passed
@github-actions github-actions Bot removed the readiness: passed Eligible automated validation passed for the current revision label Sep 1, 2026
@rnoack1
rnoack1 deleted the fix/skills-fetch-timeout branch September 1, 2026 01:01
@bolichen97

Copy link
Copy Markdown
Contributor

Open PR relationship audit

This is a consolidated, point-in-time code-level audit note. It compares complete merge-base diffs and current/merged code; it does not treat a shared topic as duplication or partial coverage as completion.

Relationship findings

  • PR #7031 is PARTIALLY_COVERED relative to this PR. Coverage is explicitly incomplete; this finding is not a completion or closure claim. Recommended action for PR #7031: REBASE. The visible-hang half of the original report is closed on main; the server-side redundant-scan half this PR removes is not, so the merged work covers part of the motivation and none of the change. Files: website/src/api/client.ts.
  • PR #7068 is PARTIALLY_COVERED relative to this PR. Coverage is explicitly incomplete; this finding is not a completion or closure claim. Recommended action for PR #7068: KEEP. The shared utility half of this PR's original change landed via PR #7062, and the primary correctly stopped re-adding it. The endpoint-specific half — the bound on /api/file-search and /api/browse-files, the isError copy branch, and the backend code contract — is absent from current main, so this is partial coverage of the infrastructure only and is not grounds for closure. Files: website/src/lib/withDeadline.ts, website/src/api/client.ts.

No PR, Issue, label, branch, or review state was changed by the relationship-note portion of this audit.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

fork Pull request from a fork (external contributor)

Projects

None yet

Development

Successfully merging this pull request may close these issues.

3 participants