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

package/dist/backend/kiro.js

@@ -5,14 +5,16 @@ 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, kiroRecordedConversation, kiroCanonicalDirectory, KiroIdentityError, kiroEngineFloor, } from "./kiro-identity.js";
+import { resolveKiroIdentity, listKiroV1Sessions, listKiroV2Sessions, confirmKiroAgentSwitch, kiroAgentConfirmed, forgetKiroIdentity, kiroIdentityNeedsStore, kiroRecordedConversation, kiroCanonicalDirectory, KiroIdentityError, kiroEngineFloor, kiroCarryCandidate, } 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";
-import { UnsupportedCliError, resolveBinary, shellQuote, validateEffort, validateModel, warnIfModelMismatch } from "./types.js";
+import { UnsupportedCliError, ResumeBlockedError, resolveBinary, shellQuote, validateEffort, validateModel, warnIfModelMismatch } from "./types.js";
+import { KIRO_SESSION_ID_COMMAND, kiroTitleCommand } from "../kiro-session-proof.js";
 import { PIE_CLASS } from "../tui-glyphs.js";
 import { KIRO_EXPIRED_LOGIN_SCREEN } from "../login-flows.js";
 import { t } from "../locale.js";
+import { sharedKiroV2StoreLane } from "./kiro-v2-store.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";
@@ -73,8 +75,10 @@ export const KIRO_STEER_VERIFIED = {
  * evidence of either an empty or a full box. The toggle key's label is whatever the user bound; it is read past, never
  * pressed.
  */
-function readKiroComposer(pane) {
-    const rows = pane.split("\n").map(row => row.replace(/\s+$/, ""));
+/** #2682: the takeover hold's key (RuntimeDialog.pattern); kiroTakeoverActive decides, this never matches a pane. */
+const KIRO_TAKEOVER_KEY = /(?!)kiro-takeover/;
+/** The composer's `›` row in `rows` and how many typed-text rows continue below it; null when there is none. */
+function findKiroComposerRow(rows) {
     let i = rows.length - 1;
     while (i >= 0 && (rows[i] === "" || /^[ \t]{20,}\S/.test(rows[i])))
         i--;
@@ -86,30 +90,47 @@ function readKiroComposer(pane) {
         continued++;
     }
     const row = rows[i];
-    if (row === undefined || !/^›[ \t]+\S/.test(row))
+    return row !== undefined && /^›[ \t]+\S/.test(row) ? { index: i, continued } : null;
+}
+function readKiroComposer(pane) {
+    const rows = pane.split("\n").map(row => row.replace(/\s+$/, ""));
+    const at = findKiroComposerRow(rows);
+    if (!at)
         return null;
+    let row = rows[at.index];
     // A placeholder is one row: with continuation rows below it, this is typed text — unless its first row is another
-    // mode's placeholder, which is then not ours to read.
-    if (continued > 0) {
-        if (/^›[ \t]+(?:Kiro is working\b|ask a question or describe a task\b|Goal (?:Active|Paused):|Editing queued message \d|Initializing\b|describe what "|running shell command\b)/.test(row))
-            return null;
-        return { mode: "text", text: row.replace(/^›[ \t]+/, "") };
+    // mode's placeholder. #2682: a narrow pane word-wraps a placeholder onto indented rows; joined, a COMPLETE known form
+    // reads as itself (an idle placeholder is then idle, not unreadable); anything else stays unreadable.
+    if (at.continued > 0) {
+        if (!/^›[ \t]+(?:Kiro is working\b|ask a question or describe a task\b|Goal (?:Active|Paused):|Editing queued message \d|Initializing\b|describe what "|running shell command\b)/.test(row)) {
+            return { mode: "text", text: row.replace(/^›[ \t]+/, "") };
+        }
+        row = [row, ...rows.slice(at.index + 1, at.index + 1 + at.continued).map(r => r.trim())].join(" ");
+        const mode = kiroPlaceholderMode(row);
+        return mode ? { mode, text: row.replace(/^›[ \t]+/, "") } : null;
     }
-    const working = String.raw `^›[ \t]+Kiro is working(?:[ \t]+·[ \t]+[^·]+?)?[ \t]+·[ \t]+`;
     const text = row.replace(/^›[ \t]+/, "");
+    const mode = kiroPlaceholderMode(row);
+    if (mode)
+        return { mode, text };
+    // Other placeholders (and anything the ASCII glyph set paints) are not typed text.
+    if (/^›[ \t]+(?:Kiro is working\b|Goal (?:Active|Paused):|Editing queued message \d|Initializing\b|describe what "|running shell command\b|ask a question or describe a task (?:\.|enter\b))/.test(row))
+        return null;
+    return { mode: "text", text };
+}
+/** The empty composer's mode from its whole placeholder (`›  …`, one row or wrapped rows joined); null when it is none. */
+function kiroPlaceholderMode(row) {
+    const working = String.raw `^›[ \t]+Kiro is working(?:[ \t]+·[ \t]+[^·]+?)?[ \t]+·[ \t]+`;
     if (new RegExp(`${working}Type to steer[ \\t]+·[ \\t]+[^·]+?[ \\t]+to queue$`).test(row))
-        return { mode: "steer", text };
+        return "steer";
     if (new RegExp(`${working}Type to queue(?:[ \\t]+·[ \\t]+[^·]+?[ \\t]+to steer)?$`).test(row))
-        return { mode: "queue", text };
+        return "queue";
     const idle = String.raw `^›[ \t]+ask a question or describe a task`;
     if (new RegExp(`${idle}[ \\t]+↵$`).test(row)
         || new RegExp(`${idle}[ \\t]+↵[ \\t]+·[ \\t]+exit plan mode: shift\\+tab$`).test(row)
         || new RegExp(`${idle}[ \\t]+·[ \\t]+/tangent to go back[ \\t]+·[ \\t]+/tangent ls to view$`).test(row))
-        return { mode: "idle", text };
-    // Other placeholders (and anything the ASCII glyph set paints) are not typed text.
-    if (/^›[ \t]+(?:Kiro is working\b|Goal (?:Active|Paused):|Editing queued message \d|Initializing\b|describe what "|running shell command\b|ask a question or describe a task (?:\.|enter\b))/.test(row))
-        return null;
-    return { mode: "text", text };
+        return "idle";
+    return null;
 }
 export function readKiroSteerComposer(pane) {
     return readKiroComposer(pane)?.mode ?? null;
@@ -119,6 +140,178 @@ export function readKiroComposerText(pane) {
     const c = readKiroComposer(pane);
     return c?.mode === "text" ? c.text : null;
 }
+/**
+ * #2683: the composer as a one-line housekeeping command (`/session-id`, `/title …`) sees it: `""` when it is
+ * positively empty (the idle placeholder, nothing else), the typed text of a single-row draft, or null for anything
+ * else (busy, another mode, wrapped text, no composer). A typed slash command opens kiro's command menu below the box
+ * (live 2.34.0, tui and V3; tests/fixtures/kiro-session-id-2681):
+ *
+ *   `› /session-id`
+ *   `/session-id    Print the current session ID`
+ *   `──────…`
+ *   ` esc to cancel · ↵ to select`
+ *
+ * and its `›` row is read past that menu. Enter there runs the highlighted entry, the command itself.
+ */
+export function readKiroCommandComposer(pane) {
+    const rows = pane.split("\n").map(row => row.replace(/\s+$/, ""));
+    let i = rows.length - 1;
+    while (i >= 0 && (rows[i] === "" || /^[ \t]{20,}\S/.test(rows[i])))
+        i--;
+    if (i >= 2 && /^ esc to cancel · .*↵ to select$/.test(rows[i]) && /^─{20,}$/.test(rows[i - 1])) {
+        let r = i - 2, entries = 0;
+        while (r >= 0 && entries < 12 && /^\/[\w-]+ {2,}\S/.test(rows[r])) {
+            r--;
+            entries++;
+        }
+        const row = rows[r];
+        return entries > 0 && row !== undefined && /^›[ \t]+\/\S/.test(row) ? row.replace(/^›[ \t]+/, "") : null;
+    }
+    const at = findKiroComposerRow(rows);
+    if (!at || at.continued > 0)
+        return null;
+    const c = readKiroComposer(pane);
+    return c?.mode === "idle" ? "" : c?.mode === "text" ? c.text : null;
+}
+/**
+ * #2683: kiro's own answer to `/session-id`, where only that answer is painted: the alert at the bottom of the chat,
+ * on the rows right above the footer (the divider within 8 rows above the composer, and the trust banner's divider
+ * above that one when it is shown). Live 2.34.0, tui and V3 (tests/fixtures/kiro-session-id-2681):
+ *
+ *   `• Session ID: <id>`
+ *   `  Resume with: kiro-cli --resume-id <id>`      (the same id)
+ *
+ * or `• Session ID: none` alone. It is a transient alert (10 s), not a turn. The same lines anywhere else (a quoted
+ * user row is `  › …`, an answer scrolls up) are not read; an agent answer that ends with them would sit in the same
+ * place, which is why the daemon also requires that the alert was not there before it typed the command. Null when no
+ * such alert is shown.
+ */
+export function readKiroSessionIdAlert(pane) {
+    const rows = pane.split("\n").map(row => row.replace(/\s+$/, ""));
+    const at = findKiroComposerRow(rows);
+    if (!at)
+        return null;
+    let d = at.index - 1;
+    while (d >= 0 && at.index - d <= 8 && !/^─{20,}$/.test(rows[d]))
+        d--;
+    if (d < 0 || !/^─{20,}$/.test(rows[d]))
+        return null;
+    if (d >= 2 && /^ \S/.test(rows[d - 1]) && /^─{20,}$/.test(rows[d - 2]))
+        d -= 2; // ` Trust All Tools active …`
+    if (rows[d - 1] === "• Session ID: none")
+        return "none";
+    const id = /^ {2}Resume with: kiro-cli --resume-id ([A-Za-z0-9][A-Za-z0-9_.-]{0,199})$/.exec(rows[d - 1] ?? "")?.[1];
+    return id !== undefined && id !== "none" && rows[d - 2] === `• Session ID: ${id}` ? id : null;
+}
+/**
+ * #2676: a collapsed paste on the composer's row. The TUI shows a paste of more than 10 lines or 500 characters as one
+ * chip (2.34.0 tui.js: `n>1 ? "${n} lines" : "${r} chars"`, then `▸`, then the `Press Tab to expand` hint):
+ *
+ *   `›  42 lines ▸   Press Tab to expand`   → 42
+ *   `›  657 chars ▸   Press Tab to expand`  → 1 (one line, shown only by its length)
+ *
+ * `text` is the row's text (readKiroComposerText). Null when it is not such a chip.
+ */
+export function readKiroCollapsedPasteLines(text) {
+    const m = /^(\d+) (lines|chars) ▸(?:[ \t]+Press Tab to expand)?$/.exec(text.trim());
+    if (!m)
+        return null;
+    return m[2] === "lines" ? Number(m[1]) : 1;
+}
+/**
+ * #2682: another program owns kiro's pane, so a paste and an Enter would go into it instead of the chat (captured on
+ * 2.34.0, tests/fixtures/kiro-2.34.0-takeover-2682). Read from kiro's own rows first:
+ * - a focused `/kvim` panel: `── Neovim · focused · Ctrl+\ to chat · :q to close ──`, or `· the agent is waiting on you:`
+ *   (unfocused, `Neovim · Ctrl+\ to edit`, the composer has the keys again);
+ * - a running `!` command (tui, V3): its PTY takes every keystroke, while the composer still reads busy
+ *   (`Kiro is working · Type to steer`) — the nearest turn above kiro's footer is `  › !…`, with only its indented
+ *   output and `• Running...` below (kiroBusyTurn; a turn it cannot see is not called a takeover here, but no busy
+ *   input is typed into it either: KiroBackend.busyTurnTakesInput);
+ * - an editor or pager kiro started (`/editor`, `/transcript`, a full-screen `!vim`/`!less`): no composer row, kiro's
+ *   temp file `kiro-editor-XXXXXX/prompt.md` or `kiro-raw-XXXXXX/conversation.md` on screen;
+ * - legacy: a `!` command running from its prompt row (the bottom row is the prompt with `!…` after the marker: the
+ *   command took the terminal before kiro painted anything else), and its `/editor` and `/reply` temp file
+ *   `q_prompt_<uuid>.md` with no prompt row at the bottom;
+ * and, only where kiro's input row is not on screen (every engine; legacy's `/editor` and `/reply` run `$EDITOR`), the
+ * program's own bottom rows: vi/vim/nvim (`~` rows, its ruler, `-- INSERT --`), less (`:`, `(END)`), more
+ * (`--More--`), nano (`GNU nano` and `^X Exit`). `/fullscreen` is not a takeover: the same composer takes input.
+ */
+export function kiroTakeoverActive(pane, ui) {
+    const rows = pane.split("\n").map(row => row.replace(/\s+$/, ""));
+    if (ui === "legacy") {
+        const prompt = kiroLegacyPromptAtBottom(rows);
+        if (prompt !== null)
+            return prompt.startsWith("!");
+        if (rows.some(row => /\/q_prompt_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.md\b/.test(row)))
+            return true;
+        return fullScreenProgramAtBottom(rows);
+    }
+    if (rows.some(row => /^─+ Neovim · (?:focused · |the agent is waiting on you: )/.test(row)))
+        return true;
+    const at = findKiroComposerRow(rows);
+    if (at) {
+        const mode = readKiroComposer(pane)?.mode;
+        return (mode === "steer" || mode === "queue") && kiroBusyTurn(rows, at.index) === "shell";
+    }
+    if (rows.some(row => /\/kiro-(?:editor|raw)-[A-Za-z0-9]{6}\/(?:prompt|conversation)\.md\b/.test(row)))
+        return true;
+    return fullScreenProgramAtBottom(rows);
+}
+/**
+ * #2682: the legacy UI's prompt row as the last non-blank row — `4% !>` (trust-all) or `4% >`, with an optional
+ * `[agent]` prefix and mode glyph, as getBottomReadyPattern — and the text after its marker (a placeholder hint, a
+ * draft, or a `!` command it is running); null when the bottom row is not the prompt.
+ */
+export function kiroLegacyPromptAtBottom(rows) {
+    const last = [...rows].reverse().find(row => row.trim() !== "");
+    const m = last === undefined ? null : /^\s*(?:\[[^\]]*\]\s*)?\d+%\s*(?:[^\s\d%!❯>]{1,2}\s+)?(?:!\s?[❯>]|❯|>)(.*)$/.exec(last);
+    return m ? m[1].trim() : null;
+}
+/**
+ * #2682: what the busy turn nearest above kiro's footer is: "shell" — a `!` command still running (its `  › !` row with
+ * only its output and `• Running...` below), "agent" — positive evidence of the agent's turn first (another user row,
+ * one of kiro's bullets, its spinner), "unknown" — no footer, or nothing that says either up to the top of the pane.
+ * Everything else is passed over, never taken as evidence: the footer and its notes however they wrap, dividers, the
+ * tray and tips, indented output.
+ */
+function kiroBusyTurn(rows, composer) {
+    let d = composer - 1;
+    while (d >= 0 && composer - d <= 8 && !/^─{20,}$/.test(rows[d]))
+        d--;
+    if (d < 0 || !/^─{20,}$/.test(rows[d]))
+        return "unknown"; // no footer divider within reach
+    for (let r = d - 1; r >= 0; r--) {
+        const row = rows[r];
+        if (/^ {2}› !/.test(row))
+            return "shell";
+        if (/^ {2}› /.test(row) || /^• (?!Running\.\.\.$)\S/.test(row) || /^\S[ \t]+(?:Thinking|Working)(?:\.{3}|…)/.test(row))
+            return "agent";
+    }
+    return "unknown";
+}
+/**
+ * #2682: whether a busy composer's typed input goes to kiro's own turn: only when that turn is seen to be the agent's.
+ * A `!` command's PTY would take it, and a turn it cannot see might be one.
+ */
+export function kiroBusyTurnTakesInput(pane) {
+    const rows = pane.split("\n").map(row => row.replace(/\s+$/, ""));
+    const at = findKiroComposerRow(rows);
+    return at !== null && kiroBusyTurn(rows, at.index) === "agent";
+}
+/** #2682: a full-screen editor or pager's own bottom rows (vi/vim/nvim, less, more, nano), whoever started it. */
+function fullScreenProgramAtBottom(rows) {
+    const shown = rows.filter(row => row.trim() !== "");
+    const last = shown[shown.length - 1]?.trim() ?? "";
+    if (last === ":" || /\(END\)$/.test(last) || /^--More--/.test(last))
+        return true; // less, more
+    if (/^-- (?:INSERT|REPLACE|VISUAL(?: LINE| BLOCK)?) --/.test(last))
+        return true; // vi modes
+    if (/\s\d+,\d+(?:-\d+)?\s+(?:All|Top|Bot|\d+%)$/.test(last))
+        return true; // vi ruler
+    if (shown.slice(-7, -1).filter(row => row === "~").length >= 3)
+        return true; // vi's empty lines
+    return shown.slice(-2).some(row => /\^X Exit/.test(row)) && rows.some(row => /^\s*GNU nano\b/.test(row)); // nano
+}
 const UNKNOWN_KIRO_COMPATIBILITY = {
     supportsLegacyUi: false,
     supportsTui: false,
@@ -974,6 +1167,34 @@ export function readActiveKiroAgent(pane, ui) {
     }
     return null;
 }
+/** Model on Kiro 2.34's live footer (status, cwd, optional branch, blank, idle composer).
+ * Separate from readActiveKiroAgent: do not widen the disabled agent-switch action's reader.
+ */
+export function readActiveKiroModel(pane, expectedAgent) {
+    if (readKiroSteerComposer(pane) !== "idle")
+        return null;
+    const rows = pane.split("\n").map(row => row.replace(/\s+$/, "")), at = findKiroComposerRow(rows);
+    if (!at)
+        return null;
+    let cwd = false, branch = false;
+    // Footer only. Never search backwards through arbitrary output or a model picker for a matching model.
+    for (let i = at.index - 1; i >= Math.max(0, at.index - 8); i--) {
+        const row = rows[i];
+        if (!row.trim() || RULE_ROW.test(row))
+            continue;
+        if (!branch && /^\s*\([^()\r\n]{1,128}\)\s*$/.test(row)) {
+            branch = true;
+            continue;
+        }
+        if (!cwd && /^\s*(?:\/[^\x00-\x1f]*|~(?:\/[^\x00-\x1f]*)?)\s*$/.test(row)) {
+            cwd = true;
+            continue;
+        }
+        const status = /^\s*(\S+) · ([A-Za-z0-9_.:/-]{1,128}) · .+$/.exec(row);
+        return cwd && status && (expectedAgent === undefined || status[1] === expectedAgent) ? status[2] : null;
+    }
+    return null;
+}
 export function planKiroLaunch(ui, compat) {
     const version = compat.version ?? "of unknown version";
     if (ui === "v3")
@@ -1104,6 +1325,9 @@ export const KIRO_RATE_LIMIT_SCREEN = new RegExp(KIRO_MESSAGE_LEAD + wrapToleran
 /** #1636: kiro's monthly cap (MonthlyLimitReached branch); see getErrorPatterns. */
 export const KIRO_REQUEST_LIMIT_SCREEN = new RegExp(KIRO_MESSAGE_LEAD + "(?:" + ["Hourly", "Daily", "Weekly", "Monthly"].map(wrapTolerant).join("|") + ")"
     + wrapTolerant(" request limit reached") + "(?:[ \\t]*$|" + wrapTolerant(" - The limits reset on") + "\\b)", "m");
+/** #2598: Kiro 2.34 lists a carried UUID in both V2 and classic; this proves presence, not a missing session. */
+export const KIRO_AMBIGUOUS_RESUME_SCREEN = new RegExp(wrapTolerant('Error: Session id "') + '[A-Za-z0-9_.\\n-]{1,256}' + wrapTolerant('" is ambiguous (')
+    + "\\d+" + wrapTolerant(" matches)."), "m");
 /** Startup budget for a `--resume` launch (60% first output, 40% ready). */
 export const KIRO_RESUME_STARTUP_BUDGET_MS = 60_000;
 export class KiroBackend {
@@ -1147,6 +1371,7 @@ export class KiroBackend {
     /** #2648: the saved model of the v2 conversation this instance has recorded, read in prepareLaunch (off the loop). */
     preparedV2Model = null;
     storePreparation = 0;
+    preparedCarry = null;
     storeKey(config) {
         return JSON.stringify([config.instanceName, config.workingDirectory, kiroCanonicalDirectory(config.workingDirectory), config.kiroUi,
             resolveCredentialProfile(config.backendOptions), !!config.skipResume, getAgendHome(), kiroV2SessionsDir(), kiroCanonicalDirectory(kiroV2SessionsDir())]);
@@ -1163,6 +1388,7 @@ export class KiroBackend {
         const preparation = ++this.storePreparation;
         this.preparedV2Store = null;
         this.preparedV2Model = null;
+        this.preparedCarry = null;
         if (!config || config.kiroUi !== "tui")
             return;
         if (!this.fixedCompatibility)
@@ -1173,6 +1399,29 @@ export class KiroBackend {
             return;
         const opts = { instance: config.instanceName, engine: "v2", workingDirectory: config.workingDirectory,
             credentialProfile: resolveCredentialProfile(config.backendOptions), skipResume: config.skipResume, agendHome: getAgendHome() };
+        if (!config.skipResume && this.needsCarryPreparation()) {
+            try {
+                this.preparedCarry = { key, error: null };
+                if (kiroCarryCandidate(opts)) {
+                    const reply = await sharedKiroV2StoreLane.read({ keys: [], sessionsDir: kiroV2SessionsDir(), carry: {
+                            ...opts, sessionsDir: kiroV2SessionsDir(), dbPath: kiroV1DbPath(opts.credentialProfile),
+                        } });
+                    if (preparation !== this.storePreparation || key !== this.storeKey(config))
+                        return;
+                    this.preparedCarry = { key, error: reply.kind === "unreadable" ? reply.detail : null };
+                    if (reply.kind === "unreadable")
+                        return;
+                    if (reply.carry?.archivePath)
+                        this.addLaunchWarning(t("kiro.archive_done", reply.carry.archivePath));
+                    if (reply.carry?.repaired)
+                        this.addLaunchWarning(t("kiro.carry_pin_repaired"));
+                }
+            }
+            catch (err) {
+                this.preparedCarry = { key, error: err.message };
+                return;
+            }
+        }
         if (kiroIdentityNeedsStore(opts)) {
             const store = await listKiroV2Sessions(config.workingDirectory, kiroV2SessionsDir());
             if (preparation === this.storePreparation && key === this.storeKey(config))
@@ -1187,6 +1436,27 @@ export class KiroBackend {
                 this.preparedV2Model = { key, id: recorded, model };
         }
     }
+    needsCarryPreparation() {
+        const v = /(?:^|\s)(\d+)\.(\d+)\.(\d+)/.exec(this.compatibility.version ?? "");
+        return !!v && (Number(v[1]) > 2 || (Number(v[1]) === 2 && Number(v[2]) >= 34));
+    }
+    assertCarryPrepared(config) {
+        if (config.kiroUi !== "tui" || config.skipResume || !this.needsCarryPreparation())
+            return;
+        const opts = { agendHome: getAgendHome(), instance: config.instanceName, workingDirectory: config.workingDirectory,
+            credentialProfile: resolveCredentialProfile(config.backendOptions) };
+        let required;
+        try {
+            required = !!kiroCarryCandidate(opts);
+        }
+        catch (err) {
+            throw new ResumeBlockedError(t("kiro.archive_failed", err.message), t("kiro.archive_remedy"));
+        }
+        if (this.preparedCarry?.key === this.storeKey(config) && this.preparedCarry.error)
+            throw new ResumeBlockedError(t("kiro.archive_failed", this.preparedCarry.error), t("kiro.archive_remedy"));
+        if (required && this.preparedCarry?.key !== this.storeKey(config))
+            throw new ResumeBlockedError(t("kiro.archive_failed", "carry preparation is missing"), t("kiro.archive_remedy"));
+    }
     constructor(instanceDir, compatibility) {
         this.instanceDir = instanceDir;
         this.binaryPath = resolveBinary("kiro-cli");
@@ -1241,6 +1511,10 @@ export class KiroBackend {
     readSteerComposerText(pane) {
         return this.activeUi === "legacy" ? null : readKiroComposerText(pane);
     }
+    /** #2676: the line count a collapsed paste chip on the composer's row names (readKiroCollapsedPasteLines). */
+    readSteerComposerPasteLines(text) {
+        return this.activeUi === "legacy" ? null : readKiroCollapsedPasteLines(text);
+    }
     /**
      * Live evidence (kiro-cli 2.21.0, 2026-09-03): `--resume` prints nothing
      * until the conversation comes back from the backend ("Picking up where we
@@ -1252,6 +1526,18 @@ export class KiroBackend {
     getStartupBudgetMs(ctx) {
         return ctx.resume ? KIRO_RESUME_STARTUP_BUDGET_MS : undefined;
     }
+    resumeBlockedPattern() { return KIRO_AMBIGUOUS_RESUME_SCREEN; }
+    retainedResumeBlock() {
+        const plan = this.activePlan;
+        if (!plan || plan.engine !== "v2" || plan.mode !== "resume" || !plan.id || !this.activeInstance)
+            return null;
+        let carried = true;
+        try {
+            carried = kiroCarryCandidate({ agendHome: getAgendHome(), instance: this.activeInstance, workingDirectory: plan.cwd, credentialProfile: plan.credentialProfile })?.id === plan.id;
+        }
+        catch { /* lost ownership proof is also a hold, never authority to discard history */ }
+        return carried ? { reason: t("kiro.carry_resume_failed"), remedy: t("kiro.archive_remedy") } : null;
+    }
     retriesResumeOnStartupFailure() {
         // A resume miss is far more often "the backend was slow" than "the session
         // is broken"; one more attempt before abandoning the conversation is cheap.
@@ -1286,6 +1572,7 @@ export class KiroBackend {
         // V3 has a different engine and no verified completion signal yet (#1144).
         this.replyGuardOptedIn = false;
         this.builtLaunch = null;
+        this.assertCarryPrepared(config);
         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.
@@ -1473,6 +1760,7 @@ export class KiroBackend {
         return true;
     }
     writeConfig(config) {
+        this.assertCarryPrepared(config);
         // WORKAROUND: kiro-cli ignores the "env" block of an MCP server entry — the server subprocess inherits the fleet
         // manager's env, with a stale AGEND_SOCKET_PATH from whichever daemon wrote last. Each server therefore runs
         // through a wrapper script that exports this instance's env and execs the real server.
@@ -2009,8 +2297,37 @@ export class KiroBackend {
             },
             ...kiroTrustPromptDialogs(this.activeTrustAll),
             ...kiroWorkspaceTrustDialogs(this.activeTrustAll),
+            {
+                // #2682: an editor, a pager, a `!` command or a focused /kvim owns the pane: a paste and an Enter would go into
+                // it. Last, so every dialog above keeps its own words; held for the person, never keyed.
+                pattern: KIRO_TAKEOVER_KEY,
+                keys: [],
+                description: "Kiro's terminal is in use by another program (an editor, a pager or a ! command) — finish or close it in the instance pane",
+                blocksDelivery: true,
+                holdOnly: true,
+                inputBlocked: true,
+                isActive: pane => kiroTakeoverActive(pane, this.activeUi),
+            },
         ];
     }
+    /**
+     * #2682: kiro's own input row, read positively, before an idle delivery. TUI and V3: the composer reads "idle", or
+     * "text" (a draft, as before); busy, another mode (a goal, the tray being edited) or no composer at all — an unknown
+     * full-screen program, a blank frame — is not a screen to type into. Legacy: its prompt row is the bottom row (`4% !>`,
+     * or `4% >` without trust-all, live 2.34.0), not running a `!` command. Anything else: the delivery waits.
+     */
+    /** #2682: the busy composer's input reaches kiro's own turn (kiroBusyTurnTakesInput), not a `!` command's PTY. */
+    busyTurnTakesInput(pane) {
+        return this.activeUi !== "legacy" && kiroBusyTurnTakesInput(pane);
+    }
+    idleComposerReady(pane) {
+        if (this.activeUi === "legacy") {
+            const prompt = kiroLegacyPromptAtBottom(pane.split("\n").map(row => row.replace(/\s+$/, "")));
+            return prompt !== null && !prompt.startsWith("!");
+        }
+        const mode = readKiroSteerComposer(pane);
+        return mode === "idle" || mode === "text";
+    }
     getContextUsage() {
         return null;
     }
@@ -2025,6 +2342,23 @@ export class KiroBackend {
             return null;
         return { engine: built.engine, sessionId: plan?.mode === "resume" && plan.id ? plan.id : null };
     }
+    /**
+     * M-2025: `/session-id` and `/title` exist on tui and V3 only. Legacy keeps
+     * the tmux window name and the sqlite lookup.
+     */
+    sessionProof() {
+        const ui = this.activeUi;
+        if (ui !== "tui" && ui !== "v3")
+            return null;
+        const pinned = this.transcriptLaunch()?.sessionId ?? null;
+        return {
+            pinned,
+            sessionIdCommand: KIRO_SESSION_ID_COMMAND,
+            titleCommand: this.activeInstance ? kiroTitleCommand(this.activeInstance) : null,
+            readComposer: readKiroCommandComposer,
+            readSessionIdAlert: readKiroSessionIdAlert,
+        };
+    }
     getSessionId() {
         // Kiro manages sessions internally via SQLite keyed by working directory.
         // No external session ID needed — --resume handles it automatically.