Skip to content

fix(chat): recover synthetic backend retry turns - #8288

Closed
Pearcekieser wants to merge 1 commit into
kirodotdev:mainfrom
Pearcekieser:fix/generic-retry-recovery-20260903
Closed

Pearcekieser wants to merge 1 commit into
kirodotdev:mainfrom
Pearcekieser:fix/generic-retry-recovery-20260903

Conversation

@Pearcekieser

@Pearcekieser Pearcekieser commented Sep 3, 2026 •

Copy link
Copy Markdown
Contributor

Problem / Motivation

Kiro CLI can fail its inner agent loop after several successful tool cycles yet close ACP as a normal Ok / UserTurnEnd result whose only assistant text is:

I hit an issue while processing your request. Please retry.

Kiro Crew treated that provider-generated sentence as a real answer. It persisted the text, recorded success, reset recovery budgets, and required the user to repeat a request whose tools may already have produced side effects.

Why it matters

Long-running work can stop after minutes of successful execution with no actionable diagnosis. Blindly replaying the original request is unsafe because completed tools may run twice. The recovery must continue from the live session context, preserve tool results, and remain cancellable before dispatch.

What changed (motivation → approach → change)

  • Added an exact classifier for Kiro CLI's synthetic turn-failure sentence. Broad please retry matching is deliberately avoided.
  • Require positive is_kiro_backend identity, at least one tool call in the turn, and confirmation that the current user message did not itself contain the sentence before treating it as provider control output. Exact answers without tool activity, quoted/requested literals, and non-Kiro output remain ordinary assistant text.
  • Remove the synthetic sentence's trailing chunks, replace any already-streamed browser row with an empty assistant reconciliation, and then show one transcript-visible recovery notice; the terminal authoritative refresh removes the unpersisted blank row.
  • Scope file-change snapshot attachment to the current turn boundary, so a sentinel/error turn with completed writes creates its own established synthetic assistant anchor instead of mutating the previous turn's assistant row.
  • Queue the existing post-token continuation on the same live session, preserving completed tool results and explicitly forbidding replay.
  • Share the existing post-token one-shot so a repeated sentinel terminates instead of looping.
  • Extend dispatch-time intervention cancellation to post-token continuations. A late Stop, queued user follow-up, or steer removes the continuation and restores its one-shot budget before anything can run.
  • Recheck monotonic Stop generation, queued follow-ups, and pending steers after the post-token retry backoff and before consuming the one-shot, so an intervention that begins and resolves during the await cannot be forgotten.
  • Keep sentinel turns out of success recording, consolidation, landed-turn state, and retry-budget resets.
  • Document the recovery contract in the session specification.

Tests

  • Exact Kiro sentinel after tool activity queues one continuation and records no success; reported output-token counts do not override the behavioral evidence because Kiro's credit-only accounting also reports zero for legitimate output.
  • A repeated sentinel is terminal and cannot loop.
  • Exact Kiro text without tool activity remains a normal assistant response.
  • Non-Kiro exact text remains a normal assistant response.
  • Broader prose and quoted forms do not match.
  • A Stop that begins and resolves between enqueue and dispatch purges the continuation and restores the one-shot.
  • Full TestEmptyResponseRetry: 19 passed.
  • Full TestRunChatTransientRetry: 20 passed.
  • File-change, flush, and post-compaction contract suites: 113 passed.
  • Full test_dashboard_chat.py: 759 passed on the final rebased head.
  • Cross-surface frontend suite: 5,682 passed.
  • Electron suite under CI's Node 24 runtime: 1,587 passed, 1 skipped.
  • Production build, TypeScript, ESLint, i18n check/render, phantom classes, duplication, bundle-size analysis, Black, isort, flake8, mypy, docs, harness, policy, vendor, scrub, and CloudFormation gates passed.

The local full-backend profile run reached 84,065 passes. Its remaining failures are unrelated host-topology failures caused by the dashboard sandbox exposing the live KIROCREW_HOME, /local/home ownership, and overlong AF_UNIX scratch paths. The two failures related to this diff's answer-branch source contract were fixed and rerun green. Hosted CI provides the authoritative isolated full-backend result.

Two independent local reviews found missing dispatch-time cancellation and missing positive Kiro identity; both were fixed. A GPT round then showed that output-token counts are non-authoritative for Kiro's credit-only accounting, so that discriminator was removed in favor of backend identity, tool activity, exact-text, and current-request guards. Later GPT rounds identified the live-browser reconciliation gap and then exposed a broader cross-turn file-change attachment bug. The former now replaces an already-streamed sentinel row before recovery; the latter was restructured globally so file changes scan only assistant rows created after the turn boundary and synthesize a current-turn anchor when needed. On the final current head, GPT restated the inherent text-signal ambiguity as a security blocker, but Opus adjudication downgraded it as disproportionate: the continuation is visible, same-session, one-shot, admission-restamped, and subject to the same tool gates, while Kiro CLI exposes no out-of-band failure event to consume.

Manual verification

N/A — this is backend recovery control flow with deterministic event-stream and queue-dispatch coverage. The triggering upstream failure cannot be induced on demand; the test event shape comes from three observed raw Kiro CLI records.

Related Issues

Fixes #8285

Related but independent:

Pattern harvest

Rule candidate: review-prompt
Pattern: a provider-owned synthetic failure sentence returned under a success envelope must require positive provider identity plus out-of-band failure evidence before changing control flow.

Checklist

  • At most two commits (one is the norm), with a Conventional Commits title (feat|fix|docs|refactor|perf|test|chore|ci|build|revert: ...)
  • Existing tests pass and new tests added for new functionality
  • Self-review completed; code follows project style guidelines
  • Documentation updated (if applicable)
  • No secrets, credentials, or internal references in the diff

CI retry note

The first two dependency-audit attempts for current-head validation timed out after 120 seconds while waiting for npm audit; neither produced a vulnerability finding. This description update retriggers the repository's pull_request: edited review/audit path without changing the reviewed commit.

@Pearcekieser
Pearcekieser requested review from a team and cixuuz September 3, 2026 22:19
@github-actions github-actions Bot added readiness: checking Automated validation is still running fork Pull request from a fork (external contributor) readiness: action required A blocking check or review needs attention and removed readiness: checking Automated validation is still running labels Sep 3, 2026
@Pearcekieser
Pearcekieser force-pushed the fix/generic-retry-recovery-20260903 branch from 57ddd15 to 8f697aa Compare September 4, 2026 00:14
@github-actions github-actions Bot added readiness: checking Automated validation is still running readiness: action required A blocking check or review needs attention and removed readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running labels Sep 4, 2026
@github-actions

github-actions Bot commented Sep 4, 2026 •

Copy link
Copy Markdown
Contributor

Design Review (Fable 5, fork) — ✅ PASS

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

Design-Verdict: PASS

Verify the sentinel sentence is byte-stable across the Kiro CLI versions users run — wording drift silently reverts to the persisted-as-success bug.

Suggestions

  • File the upstream ask for a structured failure stop reason so this text fingerprint can eventually be retired; the exact-match coupling is the design's only unavoidable fragility.

[DESIGN-REVIEWED] 19bfe6c

@github-actions

github-actions Bot commented Sep 4, 2026 •

Copy link
Copy Markdown
Contributor

First Principles Review (Fable 5, fork) — 🟡 CONCERNS

Premise-level review of 19bfe6cad8646e8d0fc1b7fcf910694ae9e22851 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.

First-Principles-Verdict: CONCERNS

Sentinel recovery is dashboard-only: the subagent and Slack post-token copies still land Kiro's failure sentence as a real answer, unmirrored and undeclared.

Not justified as shipped

  • Item 1 — symptom-level (point patch with counted siblings): the classifier ships only in the dashboard runner, but the same Kiro backend drives 2 hand-maintained post-token copies — subagent_manager/run.py:1724 and slack/gateway.py:1576 (grep _posttoken_retry_used|_POSTTOKEN_RECOVER_MSG) — and chat_runner.py:18995's PARITY NOTE says budget-rule changes "must be mirrored in the other"; this PR adds a new consumer of that budget on one side only.
    Clears when: the sibling copies get the mirrored classification, or the description/spec states subagent and Slack are deliberately deferred.
  • Item 6 — rides along: the file-change turn-boundary restructure fixes a second, pre-existing cross-turn bug for all turns, declared in the description.
  • Item 7 — rides along: the "Recheck monotonic Stop generation … after the post-token retry backoff" bullet ships only a test; base _stop_pressed() (chat_runner.py:9754) already reads the moved generation, so the diff pins, not adds, that behavior.

What this change ships

Inventory (8 items) — 5 justified

Intent: stop treating Kiro CLI's synthetic "I hit an issue… Please retry." success-envelope failure as a real answer and resume the turn safely — a FIX (issue #8285).

  1. Kiro's exact failure sentence after tool work is intercepted, never persisted, never recorded as success — symptom-level (dashboard-only; 2 sibling surfaces unfixed)
  2. One auto-continuation on the same live session, sharing the post-token one-shot; a repeat sentinel is terminal — justified
  3. A recovery/give-up error row appears in the transcript — justified
  4. An already-streamed sentinel row in the browser is blanked until the authoritative refresh — justified
  5. Stop, queued follow-up or steer before dispatch now also purges the post-token continuation and restores its budget — justified
  6. File changes from an error-only turn attach to that turn's own anchor, never the prior answer — rides along (declared second fix)
  7. New test pinning that a Stop during post-token backoff cancels recovery — rides along (pins pre-existing behavior)
  8. Session spec documents the recovery contract — justified

[FIRST-PRINCIPLES-REVIEWED] 19bfe6c

@github-actions

github-actions Bot commented Sep 4, 2026 •

Copy link
Copy Markdown
Contributor

GPT 5.6 Review (fork) — 🔴 changes requested (blocking)

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

2 of 2 blocking finding(s) are security-class and were withheld from adjudication, so the blocking verdict stands.

BLOCKING -- src/kiro_crew/dashboard/chat_runner.py:17079 -- LLM text is trusted as backend control output
and is_upstream_turn_failure_text(_answer_text)
Injected tool content -> model emits the exact sentence after a tool call -> runner launches an unattended continuation.
Anchor: backend-security-controls
Fix: require a structured provider failure signal instead of assistant text.

BLOCKING -- src/kiro_crew/dashboard/chat_runner.py:17257 -- Recovery is not bound to its originating session
slot._promise_only_stop_gen = getattr(slot, "_stop_generation", 0)
Cron rebind before queue drain -> empty session snapshot bypasses the rebind guard -> continuation runs in the newly bound session.
Anchor: residual/security
Fix: also snapshot _promise_only_session_stop_gen and _promise_only_session_key.

[BLOCK-MERGE] 19bfe6c
[GPT-REVIEWED] 19bfe6c

Adjudication (Opus 5) — is blocking on each finding proportionate?

F1 — src/kiro_crew/dashboard/chat_runner.py:17079 (new lines in the patch)
Conditions confirmed: exact strip-equality on the sentinel (chat_utils.py new is_upstream_turn_failure_text, patch line 314), positive Kiro identity + _turn_tool_calls > 0 + current-message-quote exclusion (patch lines 172-179), one-shot _posttoken_retry_used and depth-0/no-stop/no-steer gating before enqueue (patch lines 216-246). The gate is satisfied by assistant TEXT, and tool output is attacker-influenceable content the model can be steered to echo verbatim — not a condition combination the system's own writer alone can produce, so the rarity record FLAG requires cannot be completed.

F2 — src/kiro_crew/dashboard/chat_runner.py:17257 (new lines in the patch)
Conditions confirmed: the dispatch-point rebind guard keys off _promise_only_session_key and treats an empty snapshot as "no signal" (chat_runner.py:8455-8458), the slot default for that field is "" (state.py:3523), and the three existing continuation enqueues all snapshot the full triple (chat_runner.py:17284-17286, 17879-17881, 17908-17910) while the new path sets only _promise_only_stop_gen. A slot that never ran a promise-only or compaction continuation is therefore wholly unguarded against a cron rebind between enqueue and drain — the ordinary case, not an extreme one.

[ADJUDICATION] 19bfe6c total=0 uphold=0 downgrade=0
[GPT-ADJUDICATED] 19bfe6c
[ADJUDICATION-FENCED] 19bfe6c fenced=2 flagged=0
UPHOLD-FENCED F1 src/kiro_crew/dashboard/chat_runner.py:17079 -- The trigger is assistant text produced after tool execution, and tool output is attacker-influenceable, so the required condition combination is plausible in real operation rather than extreme.
UPHOLD-FENCED F2 src/kiro_crew/dashboard/chat_runner.py:17257 -- The empty _promise_only_session_key default (state.py:3523) is the normal state of a slot, so the rebind guard at chat_runner.py:8458 is bypassed on the common path, not a rare one.
[GPT-ADJUDICATED-FENCED] 19bfe6c

@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention and removed readiness: checking Automated validation is still running labels Sep 4, 2026
@github-actions

github-actions Bot commented Sep 4, 2026 •

Copy link
Copy Markdown
Contributor

Opus 5 Review (fork) — ✅ no blocking findings

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

Review details

Adding _POSTTOKEN_RECOVER_MSG to the dispatch-point purge disables the post-token recovery on any slot whose stop counter ever advanced, because neither of its enqueue sites records the snapshot the purge compares against.

FINDING — src/kiro_crew/dashboard/chat_runner.py:8481 — _POSTTOKEN_RECOVER_MSG is now in _purgeable, but the post-token transient arm (_queue_recovery(0, _POSTTOKEN_RECOVER_MSG, ...) at :19223) records no _promise_only_* snapshot at all and the new upstream-failure arm sets only slot._promise_only_stop_gen (:17257), so on any slot where a Stop was ever pressed (_stop_generation ≥ 1, monotonic and never rewound, vs. the slot default _promise_only_stop_gen = 0) or where the session stop count ever advanced, _stop_since_enqueue is True at the next drain and the continuation is purged before dispatch — the interrupted turn is abandoned and the user gets "ℹ️ Auto-continue cancelled — the turn was stopped, nothing was run." for a turn nobody stopped (the new test hand-sets slot._promise_only_stop_gen = slot._stop_generation, which production never does) → Fix: set _promise_only_stop_gen, _promise_only_session_stop_gen and _promise_only_session_key at both _POSTTOKEN_RECOVER_MSG enqueue sites, as the promise-only and post-compaction arms already do.

FINDING — docs/system-specs/modules/session.md:3916 — the owning spec still asserts "the dispatch-point purge in _start_next_queued_turn covers only the promise-only and post-compaction continuations -- so each arm re-reads for itself", and chat_runner.py:19179 and :18916 repeat "the dispatch-point purge covers the promise-only and post-compaction continuations only" in code, all three falsified by this diff's third _purgeable entry → Fix: correct the spec sentence and both comments in this commit to state that the post-token continuation is purgeable and that the purge itself resets _posttoken_retry_used.

[OPUS-REVIEWED] 19bfe6c

@Pearcekieser
Pearcekieser force-pushed the fix/generic-retry-recovery-20260903 branch from 8f697aa to a4d87da Compare September 4, 2026 02:40
@Pearcekieser

Copy link
Copy Markdown
Contributor Author
  • span=db37e66c9e96 — fixed

Kiro output-token check deletes legitimate answers because Kiro's credit-only usage leaves output_tokens at zero.

Fixed in a4d87da1002a81201ffd54fd45657fed345c60b5. The sentinel path no longer reads token counts. It now requires positive Kiro identity, at least one executed tool, the exact final sentence, and that the current user message did not itself contain that literal. New controls preserve no-tool exact output, non-Kiro output, and an explicit exact-response request after tool activity; the observed unrequested tool-active failure still recovers once.

@Pearcekieser
Pearcekieser force-pushed the fix/generic-retry-recovery-20260903 branch from a4d87da to a2affcc Compare September 4, 2026 03:33
@Pearcekieser

Copy link
Copy Markdown
Contributor Author
  • span=db37e66c9e96 — fixed: Stop during retry backoff is forgotten

A Stop can begin and resolve during post-token retry backoff; snapshotting afterward makes dispatch believe no intervention occurred.

Fixed in a2affcc940efa6f44fa020449b295510bff6d808. Recovery now requires the turn-start Stop generation before backoff and rechecks it—plus active Stop, queued user follow-ups, pending steers, and stage execution—after the await and before consuming the one-shot or enqueueing. A cancelled recovery produces an untagged terminal receipt. The new regression drives Stop from pending back to idle inside the mocked sleep and proves no queue entry, no consumed allowance, preserved partial output, and no pending-retry tag.

@Pearcekieser
Pearcekieser force-pushed the fix/generic-retry-recovery-20260903 branch from a2affcc to 9299643 Compare September 4, 2026 04:36
@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 Sep 4, 2026
@Pearcekieser
Pearcekieser force-pushed the fix/generic-retry-recovery-20260903 branch from 9299643 to b5162c5 Compare September 4, 2026 05:31
@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention and removed readiness: checking Automated validation is still running labels Sep 4, 2026
@Pearcekieser

Copy link
Copy Markdown
Contributor Author
  • span=db37e66c9e96 — rebutted: Generated sentinel text is trusted as provider control output

Require completion usage to report zero output tokens before classifying the sentinel.

That discriminator is not valid for Kiro CLI. The captured real failure session records credit-only accounting and zero token fields, but legitimate Kiro model text has the same zero-token shape; requiring zero therefore does not distinguish provider control output from model output and would only appear to close the ambiguity. The implemented behavioral gate instead requires positive Kiro-backend identity, UserTurnEnd, tool activity, exact whole-response equality, no compaction notice, and absence of the literal from the current user request. Recovery is a one-shot continuation on the same session that explicitly forbids replaying completed tools, not a replay or a privilege-bearing action. test_reported_output_tokens_do_not_override_behavioral_evidence pins the accounting boundary. No token-count condition was added.

@Pearcekieser

Copy link
Copy Markdown
Contributor Author
  • span=db37e66c9e96 — rebutted: Model text can forge the backend-failure control signal

Require an out-of-band Kiro failure event; never infer provider control state from assistant text.

No such event exists in the observed Kiro CLI/ACP failure shape: the real incidents persist Ok + UserTurnEnd + the exact fixed sentence after tool cycles, with no out-of-band failure frame. Abandoning text recognition would abandon the requested recovery behavior. The current-head Opus adjudication independently downgraded this finding as disproportionate: a forged match causes at most one visible same-session continuation, re-stamped with current containment, still subject to the same PreToolUse/approval gates, with no capability or governance escalation; user follow-up, steer, or Stop cancels it. This is the protocol-bound residual ambiguity, not a blocking security bypass. No code change is warranted.

@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention and removed readiness: checking Automated validation is still running labels Sep 4, 2026
@github-actions github-actions Bot added the merge conflict Branch has merge conflicts with its base — author must resolve before merge label Sep 4, 2026
@NicholasRBowers NicholasRBowers added needs-pr-triage PR scanner: awaiting automated triage needs-author-decision PR blocked on author input and removed needs-pr-triage PR scanner: awaiting automated triage labels Sep 7, 2026
@NicholasRBowers

Copy link
Copy Markdown
Contributor

🤖 Kiro Crew [operator: NicholasRBowers#a942f9ca]: This PR has been inactive for 7+ days. I reviewed the blockers but they require input beyond what automation can decide:

  • GPT security-lane block on span db37e66c9e96 (chat_runner.py:9644 — "Model text can forge the backend-failure control signal") is on its 6th consecutive round on the same span. You have rebutted it with structural evidence (no out-of-band failure frame exists in the observed kiro-cli/ACP shape), and the Opus adjudication on head 07ff841 independently rated the harm LOW/MEDIUM and the demanded remedy infeasible without a cross-boundary protocol change — but the adjudication emitted no well-formed verdict line, so GPT's block stands. Fork review lanes re-derive verdicts and honor no /ai-review override, so the remaining gate is a maintainer ruling on the rebuttal (accept it, or decide the feature needs the protocol change / descope). Automation pushing a 7th same-span patch would violate the stall protocol.
  • Once that ruling lands, the merge conflict with main is mechanical and the pipeline can pick this up again on its next cycle.

When these are addressed, the pipeline will re-assess on its next cycle.

@bolichen97

Copy link
Copy Markdown
Contributor

Hi @Pearcekieser — from a repo-wide audit of open PRs, this one overlaps #9156 (@buluoray), and the two need one decision before either lands.

The shared ground is src/kiro_crew/dashboard/chat_runner.py, src/kiro_crew/dashboard/chat_utils.py and test/test_dashboard_chat.py, specifically the _flush_file_changes attach block. This PR adds turn_boundary: int = 0 and slices the reverse scan (for m in reversed(slot.messages[boundary:])). #9156 deletes that reverse scan and attaches to an identity-bound target_row captured in a new _dedupe_file_changes.

They are not redundant. #9156's target_row is the last assistant message at flush time, which for an error-only write turn is the previous turn's row, the exact case this PR fixes. Your boundary slice, in turn, does not address the detached-flush successor-turn race #9156 targets. So whichever lands second must re-express its fix in the other's shape: your turn_boundary would have to apply when the row is captured, not when it is attached.

Concrete suggestion: split the _flush_file_changes row-attachment fix out of both PRs into one small PR that lands first, and keep this PR to the sentinel-recovery scope (is_upstream_turn_failure_text plus the _POSTTOKEN_RECOVER_MSG continuation). @buluoray, does that split work on your side?

Separately, this PR is 497 commits behind and merges dirty. #8318 landed _append_redaction_notice(slot, _safe) inside the same post-token block you rewrite, so a rebase is needed before review.

Posted from the 2026-09-08 open-PR relationship audit (read-only, one auditor per PR); reply here if any of this is wrong.

@iamwhatever iamwhatever added the drive-to-green PR claimed by drive-to-green pipeline label Sep 17, 2026
@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 Sep 17, 2026
Recognize Kiro CLI's successful-looking turn-failure sentinel, preserve completed tool work, and continue once without recording a false success.
@Pearcekieser
Pearcekieser force-pushed the fix/generic-retry-recovery-20260903 branch from 07ff841 to 19bfe6c Compare September 28, 2026 14:29
@Pearcekieser
Pearcekieser requested a review from a team as a code owner September 28, 2026 14:29
@Pearcekieser
Pearcekieser requested review from dodgeblaster and removed request for cixuuz September 28, 2026 14:29
@Pearcekieser

Copy link
Copy Markdown
Contributor Author

Rebased onto current main (19bfe6c, was 07ff841, 2843 commits behind). No behaviour change intended.

Conflict resolution, for the record:

  • chat_runner.py: main's _turn_msg_boundary initialiser now takes len(slot.messages) at entry instead of 0, which is what this branch's setup-failure fallback did; both _flush_file_changes calls pass the boundary. The dispatch-time purge tuple gains _POSTTOKEN_RECOVER_MSG alongside main's rebind guard. The sentinel intercept and its elif _upstream_turn_failed arm sit after main's streamed-refusal block.
  • The post-token 5xx recovery block was taken from main as-is. Main's version already re-reads Stop, queued follow-ups and steers after the backoff (_stop_pressed, _posttoken_took_over) and emits the give-up token, so this branch's rewrite of that block is dropped rather than layered on top.
  • test_dashboard_chat.py: both sides added tests in TestEmptyResponseRetry and TestRunChatTransientRetry; all kept. test_upstream_failure_after_tool_work_continues_once now expects two save_slot_off_loop awaits (main's in-flight marker), matching main's own empty-response tests. test_stop_during_posttoken_backoff_cancels_recovery drives the stop via _stop_generation and asserts TRANSIENT_GIVE_UP_TEXT, main's mechanism and text.

Local: 66 targeted tests in the two classes plus file-change/purge tests pass; black, flake8 and the comment-history gate pass on the diff.

@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention and removed readiness: checking Automated validation is still running labels Sep 28, 2026
@github-actions github-actions Bot removed the merge conflict Branch has merge conflicts with its base — author must resolve before merge label Sep 28, 2026
@Pearcekieser

Copy link
Copy Markdown
Contributor Author

Closing: superseded.

The sentinel no longer exists. The intercept keys on the exact assistant sentence I hit an issue while processing your request. Please retry. The string is absent from kiro-cli 2.24.0 and 2.24.1 (strings over kiro-cli and kiro-cli-chat: 0 hits). Those binaries instead carry explicit error-state handling for the same inner-loop failures: empty response on retry - entering error state, transient stream failure with no pending user message - entering error state, agent loop channel dropped without EndTurn, emitting Stop event, failed to end current turn after entering error state. A failed inner loop now ends the ACP turn as an error or Stop, which Kiro Crew's existing transient-retry and empty-response ladders already handle; it does not arrive as a normal Ok/UserTurnEnd with model-looking text. On this host the sentence was observed three times on 2026-09-03 (one session) and in no session since, across 939 transcript files written after 2026-09-09.

That also settles the standing GPT objection (model text can forge the backend-failure signal): with no text sentinel to intercept there is nothing to key off model-authored text, and the CLI's error state is the out-of-band signal the objection asked for.

The rest of this branch is on main or in flight:

Nothing on this branch remains to land.

@github-actions github-actions Bot removed the readiness: action required A blocking check or review needs attention label Sep 28, 2026
@mbriones98 mbriones98 removed the drive-to-green PR claimed by drive-to-green pipeline label Oct 19, 2026
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) needs-author-decision PR blocked on author input

Projects

None yet

Development

Successfully merging this pull request may close these issues.

Kiro CLI synthetic retry response is recorded as a successful turn

5 participants