@songsid/agend 2.3.2-beta.1 → 2.3.2-beta.10

package/dist/backend/kiro.js

@@ -5,7 +5,7 @@ import { homedir } from "node:os";
 import { getAgendHome } from "../paths.js";
 import { credentialHomeSpec, credentialProfileHome, credentialProfileStoreHome, prepareCredentialProfileHome, resolveCredentialProfile, } from "./credential-profile.js";
 import { kiroAgentName, kiroFleetTag, writeKiroAgent, removeKiroAgent, writeSharedKiroMcpEntries, removeSharedKiroMcpEntries, writeTaggedKiroSteering, removeTaggedKiroSteering, } from "./kiro-agent.js";
-import { resolveKiroIdentity, listKiroV1Sessions, listKiroV2Sessions, confirmKiroAgentSwitch, kiroAgentConfirmed, forgetKiroIdentity, kiroIdentityNeedsStore, kiroCanonicalDirectory, KiroIdentityError, } from "./kiro-identity.js";
+import { resolveKiroIdentity, listKiroV1Sessions, listKiroV2Sessions, confirmKiroAgentSwitch, kiroAgentConfirmed, forgetKiroIdentity, kiroIdentityNeedsStore, kiroRecordedConversation, kiroCanonicalDirectory, KiroIdentityError, kiroEngineFloor, } from "./kiro-identity.js";
 import { readKiroLedger, kiroHasNoLaunchRecord } from "./kiro-engine-ledger.js";
 import { execFileSync } from "node:child_process";
 import { writeFileSync, chmodSync, statSync } from "node:fs";
@@ -13,6 +13,7 @@ import { UnsupportedCliError, resolveBinary, shellQuote, validateEffort, validat
 import { PIE_CLASS } from "../tui-glyphs.js";
 import { KIRO_EXPIRED_LOGIN_SCREEN } from "../login-flows.js";
 import { t } from "../locale.js";
+import { decideKiroModelError, readKiroKnownModels, readKiroModelRecords, readKiroV1SavedModel, readKiroV2SavedModel, writeKiroModelRecords, KIRO_FALLBACK_MODEL } from "./kiro-retired-model.js";
 import { recordKiroLaunch } from "./kiro-engine-ledger.js";
 import { forgetKiroV3Identity, resolveKiroV3Resume } from "./kiro-v3-identity.js";
 // Kiro CLI feature gates. These are deliberately separate: the flags shipped
@@ -40,7 +41,7 @@ export const KIRO_INSTANCE_AGENT_MIN = "2.21.0";
  * the binary's own --help instead of the version table, and the operator is
  * told the version is unverified.
  */
-export const KIRO_TESTED_MAX = "2.33.0";
+export const KIRO_TESTED_MAX = "2.34.0";
 /**
  * kiro-cli versions, per TUI front-end, whose mid-turn steering AgEnD drives (#1405). Only kiro's TUI steers — typed
  * input while a turn runs is injected into it ("steer", the default) or held for its end ("queue", Ctrl+S toggles); the
@@ -48,10 +49,13 @@ export const KIRO_TESTED_MAX = "2.33.0";
  * queued message mid-tool — has been captured (tests/fixtures/kiro-steer-1405, 2026-10-08: 2.27.1 `--tui
  * --agent-engine=v2` and `--v3`, 2.28.0 `--tui --agent-engine=v2`; identical rows on all three). Any other version,
  * 2.28.0's v3, the legacy UI and an undetected version all deliver a steer as an ordinary message after the turn.
+ * 2.34.0 TUI was checked on the user-authorized #2598 D5 run (tests/fixtures/kiro-2.34.0-tui-d5):
+ * native steer during a read-only tool, a fleet message queued mid-tool, and a native queue entry in the busy turn.
  */
 export const KIRO_STEER_VERIFIED = {
     "2.27.1": ["tui", "v3"],
     "2.28.0": ["tui"],
+    "2.34.0": ["tui"],
 };
 /**
  * The TUI composer's interrupt mode, read off its own row: the LAST row starting at column 0 with `›` (transcript user
@@ -133,11 +137,12 @@ const warnedVersionGateCacheKeys = new Set();
  * This broad test is only a safety hold: it must never select an option or
  * claim a service outage. A ready prompt below the picker makes it history.
  */
+const KIRO_MODEL_PICKER_HEADER = /^\s*Select model(?: \(type to search\):|:\s+type to search)\s*$/m;
 function kiroModelPickerAtTail(pane) {
     const lines = pane.replace(/\r/g, "").split("\n");
     let pickerIndex = -1;
     for (let index = lines.length - 1; index >= 0; index--) {
-        if (/^\s*Select model \(type to search\):\s*$/.test(lines[index])) {
+        if (KIRO_MODEL_PICKER_HEADER.test(lines[index])) {
             pickerIndex = index;
             break;
         }
@@ -145,7 +150,8 @@ function kiroModelPickerAtTail(pane) {
     if (pickerIndex < 0)
         return false;
     const tail = lines.slice(pickerIndex + 1);
-    if (tail.some(line => /^\s*\d+%[^\n]*[!❯>]\s+\S/.test(line)))
+    const composer = readKiroSteerComposer(tail.join("\n"));
+    if (tail.some(line => /^\s*\d+%[^\n]*[!❯>]\s+\S/.test(line)) || (composer !== null && composer !== "text"))
         return false;
     return tail.some(line => /^\s*[>❯›]\s*\*?\s*\S/.test(line));
 }
@@ -330,6 +336,205 @@ function kiroWorkspaceTrustDialogs(trustAll) {
         },
     ];
 }
+const KIRO_MCP_INPUT_HEADER = /^\s*Input requested · \S.*$/;
+const KIRO_MCP_INPUT_FOOTER = /^\s*esc to cancel · ↑↓ to navigate · enter to select(?: · ctrl\+s to submit)?$/;
+/**
+ * #2587: kiro-cli 2.34.0's V3 engine answers an MCP server's `elicitation/create` (a tool asking the user for input)
+ * with a card in place of the composer: a divider, `Input requested · <server>`, a divider, the server's message and
+ * one row per form field then Submit / Decline (form mode) — or Host, URL and Open in browser / Copy URL / I'll open it
+ * myself / Decline / Cancel (url mode) — with exactly one `❯` cursor row, a divider, and the key hints as the last row
+ * (tests/fixtures/kiro-2.34.0-audit). Bottom-anchored: the card is live only while it is what the pane ends with. The
+ * answer can carry credentials or a sign-in, so it is the person's: never a key, and no delivery's Enter may land in it.
+ */
+export function kiroMcpInputRequestActive(pane) {
+    const rows = pane.replace(/\r/g, "").split("\n").map(row => row.trimEnd());
+    let last = rows.length - 1;
+    while (last >= 0 && !rows[last].trim())
+        last--;
+    if (last < 0 || !KIRO_MCP_INPUT_FOOTER.test(rows[last]))
+        return false;
+    const divider = (row) => row !== undefined && /^─{3,}$/.test(row.trim());
+    if (!divider(rows[last - 1]))
+        return false;
+    let header = -1;
+    for (let index = last - 2; index >= 1; index--) {
+        if (KIRO_MCP_INPUT_HEADER.test(rows[index])) {
+            header = index;
+            break;
+        }
+    }
+    if (header < 0 || !divider(rows[header - 1]) || !divider(rows[header + 1]))
+        return false;
+    const body = rows.slice(header + 2, last - 1);
+    // A V3 composer (`›` at column 0) inside means the card is history. A lone `>` is a form field's own input caret.
+    if (body.some(row => divider(row) || /^›(?:[ \t]|$)/.test(row)))
+        return false;
+    return body.filter(row => /^\s*❯\s+\S/.test(row)).length === 1;
+}
+const KIRO_QUESTION_HEADER = /^\s*(?:\S.* > )?Question$/;
+const KIRO_QUESTION_FOOTER = /^\s*esc to (?:cancel|go back) · ↑↓ to navigate(?: · space to toggle)? · ↵ to submit$/;
+/**
+ * #2592: kiro's V3 engine shows the agent's question to the user (`question_request`) as a card in place of the
+ * composer: a divider, `Question` (or `<name> > Question`), the question, numbered options (a description row under
+ * one, `(recommended)` after one) and `Type a different answer…`, a divider, and the key hints as the last row — or, in
+ * an option's sub-options, `[✓] <title>` rows and `esc to go back · … · space to toggle · ↵ to submit`
+ * (tests/fixtures/kiro-question-2592; unchanged from 2.33.1 to 2.34.0). Any typed character turns the card into a free
+ * answer and Enter submits it, so a delivered message would become the answer to a question nobody read. The person
+ * answers it in the pane (the user's decision on #2592); it is never keyed. Bottom-anchored like
+ * kiroMcpInputRequestActive: the header is the row right under the nearest divider above the key hints' divider.
+ */
+export function kiroQuestionCardActive(pane) {
+    const rows = pane.replace(/\r/g, "").split("\n").map(row => row.trimEnd());
+    let last = rows.length - 1;
+    while (last >= 0 && !rows[last].trim())
+        last--;
+    if (last < 0 || !KIRO_QUESTION_FOOTER.test(rows[last]))
+        return false;
+    const divider = (row) => row !== undefined && /^─{3,}$/.test(row.trim());
+    if (!divider(rows[last - 1]))
+        return false;
+    let top = last - 2;
+    while (top >= 0 && !divider(rows[top]))
+        top--;
+    if (top < 0 || !KIRO_QUESTION_HEADER.test(rows[top + 1] ?? ""))
+        return false;
+    const body = rows.slice(top + 2, last - 1);
+    // The question, then the options: a V3 composer (`›` at column 0) among them means the card is history.
+    if (body.length < 2 || body.some(row => /^›(?:[ \t]|$)/.test(row)))
+        return false;
+    return body.filter(row => /^\s*❯\s+\S/.test(row)).length === 1;
+}
+/** #2675: the live card's rows — the header row, the body between it and the key hints' divider, and the key hints. */
+function kiroCardRows(pane, headerAt) {
+    const rows = pane.replace(/\r/g, "").split("\n").map(row => row.trimEnd());
+    let last = rows.length - 1;
+    while (last >= 0 && !rows[last].trim())
+        last--;
+    const header = headerAt(rows, last);
+    return header < 0 ? null : { header: rows[header].trim(), body: rows.slice(header + 1, last - 1), footer: rows[last].trim(), width: rows[last - 1].trim().length };
+}
+const KIRO_QUESTION_OPTION_ROW = /^ (❯| ) (\d+)\. (.*?)( \(recommended\))?$/;
+const KIRO_QUESTION_SUBOPTION_ROW = /^ (❯| ) \[(✓| )\] (.*)$/;
+const KIRO_QUESTION_FREE_ROW = /^ (❯| ) (Type a different answer…|or type feedback to request changes)$/;
+/**
+ * #2675: the live Question card (see kiroQuestionCardActive), read for a person to answer from the chat: the question,
+ * the numbered options (`(recommended)` and the description row under one), the typed-answer row, and where the `❯`
+ * is (tui.js `A0`; tests/fixtures/kiro-question-2592). On a sub-options page the rows are the `[✓]` boxes; while an
+ * answer is being typed the last row is `❯ <text>`. A row the shapes above do not account for is a wrapped title (the
+ * card's own indent) or description (deeper), joined to the row it continues; one before any option belongs to the
+ * question. Null when the card is not live, or when it is in a shape this reader does not know.
+ */
+export function readKiroQuestionCard(pane) {
+    if (!kiroQuestionCardActive(pane))
+        return null;
+    const card = kiroCardRows(pane, (rows, last) => {
+        let top = last - 2;
+        while (top >= 0 && !/^─{3,}$/.test(rows[top].trim()))
+            top--;
+        return top + 1;
+    });
+    if (!card)
+        return null;
+    const page = /space to toggle/.test(card.footer) ? "suboptions" : "options";
+    const question = [];
+    const options = [];
+    let cursor = null, freeText = false, typed = null, freeRow = false;
+    for (const row of card.body) {
+        const option = page === "options" ? KIRO_QUESTION_OPTION_ROW.exec(row) : null;
+        const sub = page === "suboptions" ? KIRO_QUESTION_SUBOPTION_ROW.exec(row) : null;
+        const free = page === "options" ? KIRO_QUESTION_FREE_ROW.exec(row) : null;
+        if (freeRow)
+            return null; // nothing follows the typed-answer row
+        if (option && Number(option[2]) === options.length + 1) {
+            if (option[1] === "❯")
+                cursor = options.length;
+            options.push({ n: options.length + 1, title: option[3], recommended: option[4] !== undefined, description: null });
+        }
+        else if (sub) {
+            if (sub[1] === "❯")
+                cursor = options.length;
+            options.push({ n: options.length + 1, title: sub[3], recommended: false, description: null, checked: sub[2] === "✓" });
+        }
+        else if (free) {
+            freeText = true;
+            freeRow = true;
+            if (free[1] === "❯")
+                cursor = options.length;
+        }
+        else if (page === "options" && options.length > 0 && /^ ❯ /.test(row)) {
+            freeText = true;
+            freeRow = true;
+            typed = row.slice(3);
+        }
+        else if (!row.trim()) {
+            continue;
+        }
+        else if (options.length === 0) {
+            question.push(row.replace(/^ /, ""));
+        }
+        else {
+            const lastOption = options[options.length - 1];
+            if (/^ {5,}\S/.test(row))
+                lastOption.description = lastOption.description === null ? row.trim() : `${lastOption.description} ${row.trim()}`;
+            else if (lastOption.description === null)
+                lastOption.title = `${lastOption.title} ${row.trim()}`;
+            else
+                return null;
+        }
+    }
+    if (options.length === 0 || question.length === 0)
+        return null;
+    const typing = typed !== null;
+    if (typing ? cursor !== null : cursor === null)
+        return null;
+    const titles = options.map(option => `${option.n}. ${option.title}`).join("\n");
+    return {
+        kind: "question", identity: `${card.header}\n${question.join("\n")}\n${page === "suboptions" ? "sub" : "options"}\n${titles}`,
+        title: card.header, question: question.join("\n").trim(), page: typing ? "freetext" : page, options, freeText, cursor, typed, rowWidth: card.width,
+    };
+}
+const KIRO_MCP_INPUT_ACTIONS = new Set(["Submit", "Decline", "Open in browser", "Copy URL", "I'll open it myself", "Cancel"]);
+/**
+ * #2675: the live MCP `Input requested` card (see kiroMcpInputRequestActive), read for the chat: the server, the body
+ * as painted, with the `URL:` row masked (a sign-in link stays in the pane), its action rows, and the `❯` row. Its
+ * identity is the server, the mode, the message's first row and the actions: moving or filling in a field keeps it.
+ */
+export function readKiroMcpInputCard(pane) {
+    if (!kiroMcpInputRequestActive(pane))
+        return null;
+    const card = kiroCardRows(pane, (rows, last) => {
+        for (let index = last - 2; index >= 1; index--)
+            if (KIRO_MCP_INPUT_HEADER.test(rows[index]))
+                return index;
+        return -1;
+    });
+    if (!card)
+        return null;
+    // The URL row is masked, and so is every row after it up to the next action row: a long URL wraps (#2677 review).
+    let inUrl = false;
+    const body = card.body.slice(1).flatMap(row => {
+        if (/^\s*URL: /.test(row)) {
+            inUrl = true;
+            return [row.replace(/URL: .*$/, "URL: (shown in the instance pane)")];
+        }
+        if (inUrl && KIRO_MCP_INPUT_ACTIONS.has(row.replace(/^ ❯ /, "   ").trim()))
+            inUrl = false;
+        return inUrl ? [] : [row];
+    });
+    const strip = (row) => row.replace(/^ ❯ /, "   ").trim();
+    const cursorRow = body.find(row => /^\s*❯\s+\S/.test(row));
+    if (!cursorRow)
+        return null;
+    return {
+        kind: "input", server: card.header.replace(/^Input requested · /, ""),
+        mode: /ctrl\+s to submit/.test(card.footer) ? "form" : "url",
+        rows: body.map(row => row.replace(/^ ❯ /, "   ").replace(/^ {3}/, "")).filter(row => row.trim()),
+        actions: body.map(strip).filter(row => KIRO_MCP_INPUT_ACTIONS.has(row)),
+        cursorRow: strip(cursorRow),
+        // The focused field paints extra rows (its value, its caret) and a typed value changes its row: neither is another request.
+        identity: `${card.header}\n${/ctrl\+s to submit/.test(card.footer) ? "form" : "url"}\n${strip(body[0] ?? "")}\n${body.map(strip).filter(row => KIRO_MCP_INPUT_ACTIONS.has(row)).join("|")}`,
+    };
+}
 /**
  * Kiro's service-unavailable path opens the same picker as `/model`, but only
  * the former needs incident escalation. The runtime scanner and delivery gate
@@ -342,7 +547,7 @@ export function kiroUnavailableModelPickerActive(pane) {
     const lines = pane.replace(/\r/g, "").split("\n");
     let pickerIndex = -1;
     for (let i = lines.length - 1; i >= 0; i--) {
-        if (/^\s*Select model \(type to search\):\s*$/.test(lines[i])) {
+        if (KIRO_MODEL_PICKER_HEADER.test(lines[i])) {
             pickerIndex = i;
             break;
         }
@@ -634,6 +839,17 @@ function compatibilityFromHelp(version, help) {
         source: "help",
     };
 }
+/**
+ * #2598 (D1): kiro-cli-chat skips its self-update when this is set (2.30.0 and 2.34.0 both read it). AgEnD pins the
+ * kiro version it has audited; an in-place update can swap the engine a running fleet depends on (3.0 drops legacy).
+ * Every chat AgEnD starts carries it: the instance launch (a shell prefix) and the probes (their child env). The
+ * host-wide `app.disableAutoupdates` setting is the operator's half; this holds even where that was never set.
+ */
+export const KIRO_NO_AUTO_UPDATE = "KIRO_NO_AUTO_UPDATE";
+/** A kiro child's environment: the given one (default: ours) with self-update off. */
+export function kiroChildEnv(base = process.env) {
+    return { ...base, [KIRO_NO_AUTO_UPDATE]: "1" };
+}
 /**
  * Probe once per binary generation. A version AgEnD has run (<= TESTED_MAX)
  * is answered from the table without a second CLI call; anything newer, or a
@@ -645,6 +861,7 @@ export function probeKiroCliCompatibility(binaryPath, run = (binary, args) => me
     encoding: "utf-8",
     timeout: 5000,
     stdio: ["ignore", "pipe", "ignore"],
+    env: kiroChildEnv(),
 }))) {
     return measureSyncWork("kiro.compatibilitySync", () => probeKiroCliCompatibilitySync(binaryPath, run));
 }
@@ -673,6 +890,8 @@ function nextPatch(version) {
     const [major, minor, patch] = parseSemver(version);
     return `${major}.${minor}.${patch + 1}`;
 }
+/** #2598 B3: engines in the order a conversation can move between them (never back). */
+const KIRO_ENGINE_RANK = { legacy: 1, tui: 2, v3: 3 };
 /** Binary generations already told they cannot isolate (once each). */
 const warnedNoInstanceAgentKeys = new Set();
 /** Instances already told about an untagged steering file (once each). */
@@ -913,6 +1132,8 @@ export class KiroBackend {
     activeTrustAll = true;
     /** Version-gate notice for the launch just built (consumeLaunchWarning). */
     launchWarning = null;
+    /** #2648: what this launch's model came from, for a model error to be judged by (decideKiroModelError). */
+    launchModels = null;
     /**
      * What this launch attempt resumes and as which agent (#906), resolved once per attempt in writeConfig — it claims
      * conversations and records fresh starts — and read by the buildCommand that follows it.
@@ -923,6 +1144,8 @@ export class KiroBackend {
     /** #1218: the last launch built in full (cleared when a build starts, set only when it returns). */
     builtLaunch = null;
     preparedV2Store = null;
+    /** #2648: the saved model of the v2 conversation this instance has recorded, read in prepareLaunch (off the loop). */
+    preparedV2Model = null;
     storePreparation = 0;
     storeKey(config) {
         return JSON.stringify([config.instanceName, config.workingDirectory, kiroCanonicalDirectory(config.workingDirectory), config.kiroUi,
@@ -939,6 +1162,7 @@ export class KiroBackend {
     async prepareLaunch(config) {
         const preparation = ++this.storePreparation;
         this.preparedV2Store = null;
+        this.preparedV2Model = null;
         if (!config || config.kiroUi !== "tui")
             return;
         if (!this.fixedCompatibility)
@@ -954,6 +1178,14 @@ export class KiroBackend {
             if (preparation === this.storePreparation && key === this.storeKey(config))
                 this.preparedV2Store = { key, store };
         }
+        // #2648: only for an instance with no model of its own, and only the conversation it has recorded (the resolver
+        // in writeConfig may pick another — then nothing is foreseen, and a model error is handled after the launch).
+        const recorded = !config.model && !config.skipResume ? kiroRecordedConversation(opts) : null;
+        if (recorded) {
+            const model = await readKiroV2SavedModel(kiroV2SessionsDir(), recorded);
+            if (preparation === this.storePreparation && key === this.storeKey(config))
+                this.preparedV2Model = { key, id: recorded, model };
+        }
     }
     constructor(instanceDir, compatibility) {
         this.instanceDir = instanceDir;
@@ -1055,6 +1287,12 @@ export class KiroBackend {
         this.replyGuardOptedIn = false;
         this.builtLaunch = null;
         const ui = config.kiroUi ?? "legacy";
+        // #2598 B3: never back onto an older engine than this instance has run on — that resumes the frozen copy and loses
+        // everything done since. Before any probe: no kiro-cli flag or version changes the answer.
+        const floor = kiroEngineFloor(getAgendHome(), config.instanceName);
+        if (floor && KIRO_ENGINE_RANK[ui] < KIRO_ENGINE_RANK[floor === "v2" ? "tui" : "v3"]) {
+            throw new UnsupportedCliError(t("kiro.engine_floor", config.instanceName, ui, floor === "v2" ? "tui" : "v3"));
+        }
         // Every launch re-reads the binary generation: a crash-respawn reuses this
         // backend, and kiro-cli may have replaced itself in place since the last
         // launch (an auto-update to a release without this instance's engine).
@@ -1075,7 +1313,8 @@ export class KiroBackend {
         const plan = planKiroLaunch(ui, this.compatibility);
         if (plan.kind === "refuse")
             throw new UnsupportedCliError(plan.reason);
-        let cmd = `${this.binaryPath} chat`;
+        // #2598: a shell assignment, so it reaches kiro-cli-chat through `kiro-cli chat` and any credential-home prefix.
+        let cmd = `${KIRO_NO_AUTO_UPDATE}=1 ${this.binaryPath} chat`;
         for (const flag of plan.flags)
             cmd += ` ${flag}`;
         this.noteVersionGate();
@@ -1119,17 +1358,32 @@ export class KiroBackend {
             if (id)
                 cmd += ` --resume-id ${shellQuote(id)}`;
         }
-        else if (!config.skipResume) {
-            // Legacy mode, classic/TUI: the boolean form — kiro resumes the directory's newest conversation. Not isolated
+        else if (!config.skipResume && ui === "legacy") {
+            // Legacy mode, classic: the boolean form — kiro resumes the directory's newest conversation. Not isolated
             // between instances sharing the directory (#1410); an instance launches like this only without the
             // per-instance plan (an old kiro-cli, or a conversation store AgEnD could not read on adoption).
             cmd += " --resume";
         }
+        else if (!config.skipResume && ui === "tui") {
+            // #2598 B3: never the boolean form under the TUI — it takes the directory's newest conversation from EITHER
+            // engine, and on a classic one makes a TUI fork of it (the wrong conversation, possibly another instance's). A
+            // TUI launch without its per-instance plan starts fresh instead, and says so.
+            this.addLaunchWarning(t("kiro.tui_no_plan_fresh"));
+        }
+        const resumed = lp.mode === "resume" && lp.id && (lp.engine === "v1" || lp.engine === "v2") ? { engine: lp.engine, id: lp.id } : null;
+        const fallbackModel = !config.model && resumed && config.instanceDir
+            ? this.retiredModelFallback(config, resumed, credentialProfile) : null;
+        this.launchModels = config.instanceDir
+            ? { instanceDir: config.instanceDir, ownModel: config.model ?? null, launchModel: config.model ?? fallbackModel, conversation: resumed?.id ?? null }
+            : null;
         if (config.model) {
             const model = validateModel(config.model);
             warnIfModelMismatch("kiro-cli", model);
             cmd += ` --model ${shellQuote(model)}`;
         }
+        else if (fallbackModel) {
+            cmd += ` --model ${shellQuote(validateModel(fallbackModel))}`;
+        }
         if (config.effort) {
             const effort = validateEffort(config.effort);
             if (this.compatibility.supportsEffortFlag) {
@@ -1290,6 +1544,59 @@ export class KiroBackend {
             this.addLaunchWarning(t("kiro.untagged_steering"));
         }
     }
+    /**
+     * #2648 steps 1 and 3: the model a resumed conversation is launched on instead of its saved one, or null to launch as
+     * before. Only for an instance with no model of its own. The conversation's current saved model decides, every
+     * launch: one kiro's cached list no longer has is switched to kiro's default; one it has — or, without a list, one
+     * other than the model that failed (a later /model choice, or the default kiro saved after a switch) — is launched
+     * as saved, even after an earlier switch (#2649 review). Only when the saved model cannot be read does a recorded
+     * switch (step 2's restart) still apply. Announced once per conversation; the record also keeps that dedupe.
+     */
+    retiredModelFallback(config, resumed, credentialProfile) {
+        const records = readKiroModelRecords(config.instanceDir);
+        let entry = records.switched[resumed.id];
+        const known = readKiroKnownModels(getAgendHome());
+        const prepared = this.preparedV2Model;
+        const saved = resumed.engine === "v1"
+            ? readKiroV1SavedModel({ id: resumed.id, workingDirectory: config.workingDirectory, dbPath: kiroV1DbPath(credentialProfile) })
+            : prepared && prepared.key === this.storeKey(config) && prepared.id === resumed.id ? prepared.model : null;
+        if (saved) {
+            // Step 2's restart recorded no model: the one saved now is the one that failed — unless it is the default the
+            // switch put there (kiro saves the model a launch ran on).
+            if (entry && entry.from === null && saved !== entry.to)
+                entry.from = saved;
+            const supported = known ? known.models.has(saved) : !!entry && (saved === entry.to || (entry.from !== null && saved !== entry.from));
+            if (supported || (!known && !entry)) {
+                if (entry && entry.from !== saved)
+                    this.saveModelRecords(config.instanceDir, records);
+                return null;
+            }
+            if (!entry || entry.from !== saved)
+                entry = records.switched[resumed.id] = { from: saved, to: known?.defaultModel ?? entry?.to ?? KIRO_FALLBACK_MODEL, announced: entry?.announced ?? false };
+        }
+        else if (!entry) {
+            return null;
+        }
+        if (!entry.announced) {
+            this.addLaunchWarning(t("kiro.retired_model_switched", config.instanceName, entry.from ?? t("kiro.retired_model_unknown"), entry.to));
+            entry.announced = true;
+        }
+        this.saveModelRecords(config.instanceDir, records);
+        return entry.to;
+    }
+    saveModelRecords(instanceDir, records) {
+        try {
+            writeKiroModelRecords(instanceDir, records);
+        }
+        catch { /* the next launch decides again; at worst it says so again */ }
+    }
+    /** #2648 steps 2 and 4: what a model error on this launch should do (records it); null before any launch. */
+    onModelError() {
+        const m = this.launchModels;
+        if (!m)
+            return null;
+        return decideKiroModelError(m.instanceDir, m, readKiroKnownModels(getAgendHome())?.defaultModel ?? KIRO_FALLBACK_MODEL);
+    }
     addLaunchWarning(message) {
         this.launchWarning = this.launchWarning ? `${this.launchWarning}\n${message}` : message;
     }
@@ -1656,7 +1963,7 @@ export class KiroBackend {
                 // picker. Its choices range across credit multipliers and capability
                 // tiers, so this must be a human decision, never an automatic Enter or
                 // Escape. The ordinary /model menu alone is intentionally not matched.
-                pattern: /^\s*Select model \(type to search\):\s*$/m,
+                pattern: KIRO_MODEL_PICKER_HEADER,
                 keys: [],
                 description: "Kiro model unavailable — choose a replacement model in the instance pane",
                 blocksDelivery: true,
@@ -1668,7 +1975,7 @@ export class KiroBackend {
                 // Any active /model picker owns stdin, even if a future Kiro release
                 // changes the exact warning, credit wording or row layout. Keep this
                 // after the verified-outage case: it never labels /model as an outage.
-                pattern: /^\s*Select model \(type to search\):\s*$/m,
+                pattern: KIRO_MODEL_PICKER_HEADER,
                 keys: [],
                 description: "Kiro model picker — manual selection required",
                 blocksDelivery: true,
@@ -1676,6 +1983,30 @@ export class KiroBackend {
                 inputBlocked: true,
                 isActive: kiroModelPickerAtTail,
             },
+            {
+                // #2587: an MCP server's input request (kiro-cli 2.34.0 V3) owns stdin until the person answers or cancels it.
+                pattern: KIRO_MCP_INPUT_HEADER,
+                keys: [],
+                description: "Kiro MCP server is asking for input — answer it in the instance pane",
+                blocksDelivery: true,
+                holdOnly: true,
+                inputBlocked: true,
+                isActive: kiroMcpInputRequestActive,
+                requestIdentity: pane => readKiroMcpInputCard(pane)?.identity ?? null,
+                remoteCard: readKiroMcpInputCard,
+            },
+            {
+                // #2592: the agent's question to the user owns stdin until the person answers or cancels it.
+                pattern: KIRO_QUESTION_HEADER,
+                keys: [],
+                description: "Kiro agent is asking a question — answer it in the instance pane",
+                blocksDelivery: true,
+                holdOnly: true,
+                inputBlocked: true,
+                isActive: kiroQuestionCardActive,
+                requestIdentity: pane => readKiroQuestionCard(pane)?.identity ?? null,
+                remoteCard: readKiroQuestionCard,
+            },
             ...kiroTrustPromptDialogs(this.activeTrustAll),
             ...kiroWorkspaceTrustDialogs(this.activeTrustAll),
         ];
@@ -1684,6 +2015,16 @@ export class KiroBackend {
         return null;
     }
     logLaunch() { return this.builtLaunch ? { ...this.builtLaunch } : null; }
+    /**
+     * #2598 B1: the store is the launch's engine's (v1 = the classic sqlite store, v2 = the TUI's session files), and the
+     * conversation is the one the launch resumed by id. A fresh or legacy-mode launch owns no id yet.
+     */
+    transcriptLaunch() {
+        const built = this.builtLaunch, plan = this.activePlan;
+        if (!built)
+            return null;
+        return { engine: built.engine, sessionId: plan?.mode === "resume" && plan.id ? plan.id : null };
+    }
     getSessionId() {
         // Kiro manages sessions internally via SQLite keyed by working directory.
         // No external session ID needed — --resume handles it automatically.
@@ -1709,7 +2050,7 @@ export class KiroBackend {
      */
     readModelsPayload() {
         try {
-            const out = execFileSync(this.binaryPath, ["chat", "--list-models", "--format", "json"], { encoding: "utf-8", timeout: 5000, stdio: ["ignore", "pipe", "ignore"] });
+            const out = execFileSync(this.binaryPath, ["chat", "--list-models", "--format", "json"], { encoding: "utf-8", timeout: 5000, stdio: ["ignore", "pipe", "ignore"], env: kiroChildEnv() });
             const parsed = JSON.parse(out);
             const arr = Array.isArray(parsed) ? parsed : (parsed?.models ?? []);
             const models = arr.map((m) => {