[Init] Initial commit - NetMesh terminal manager

electron/bridges/terminalInterruptOutputGate.test.cjs

@@ -0,0 +1,867 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+const {
+  armTerminalInterruptOutputGate,
+  filterTerminalInterruptOutput,
+  stashPendingInterruptOutputMeta,
+  takePendingInterruptOutputMeta,
+} = require("./terminalInterruptOutputGate.cjs");
+
+test("pending interrupt metadata clears stale alternate-screen action on later unknown risk", () => {
+  const session = {};
+
+  stashPendingInterruptOutputMeta(session, {
+    droppedOutputMayAffectTerminalState: true,
+    droppedOutputAlternateScreenAction: "leave",
+  });
+  stashPendingInterruptOutputMeta(session, {
+    droppedOutputMayAffectTerminalState: true,
+  });
+
+  assert.deepEqual(takePendingInterruptOutputMeta(session), {
+    droppedOutputMayAffectTerminalState: true,
+  });
+});
+
+test("drops flood output after Ctrl+C and resumes from the interrupt echo", () => {
+  const session = {};
+
+  armTerminalInterruptOutputGate(session, {
+    now: 1000,
+    quietMs: 80,
+    maxDrainMs: 1000,
+  });
+
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "old output\n", { now: 1001 }),
+    { accepted: false, data: "", droppedBytes: 11, reason: "draining" },
+  );
+
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "more old output^C\r\n$ ", { now: 1002 }),
+    { accepted: true, data: "^C\r\n$ ", droppedBytes: 15, reason: "interrupt-echo" },
+  );
+
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "next output", { now: 1003 }),
+    { accepted: true, data: "next output", droppedBytes: 0, reason: "inactive" },
+  );
+});
+
+test("resumes output after a quiet gap when no interrupt echo is visible", () => {
+  const session = {};
+
+  armTerminalInterruptOutputGate(session, {
+    now: 2000,
+    quietMs: 80,
+    maxDrainMs: 1000,
+  });
+
+  assert.equal(filterTerminalInterruptOutput(session, "old output", { now: 2001 }).accepted, false);
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "$ ", { now: 2100 }),
+    { accepted: true, data: "$ ", droppedBytes: 0, reason: "prompt-gap" },
+  );
+});
+
+test("accepts an immediate prompt when the remote does not echo Ctrl+C", () => {
+  const session = {};
+
+  armTerminalInterruptOutputGate(session, {
+    now: 2500,
+    quietMs: 80,
+    maxDrainMs: 1000,
+  });
+
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "$ ", { now: 2501 }),
+    { accepted: true, data: "$ ", droppedBytes: 0, reason: "prompt-candidate" },
+  );
+
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "next output", { now: 2502 }),
+    { accepted: true, data: "next output", droppedBytes: 0, reason: "inactive" },
+  );
+});
+
+test("resumes output when interrupt echo is split across chunks", () => {
+  const session = {};
+
+  armTerminalInterruptOutputGate(session, {
+    now: 3500,
+    quietMs: 80,
+    maxDrainMs: 1000,
+  });
+
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "old output", { now: 3501 }),
+    { accepted: false, data: "", droppedBytes: 10, reason: "draining" },
+  );
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "^", { now: 3502 }),
+    { accepted: false, data: "", droppedBytes: 1, reason: "draining" },
+  );
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "C\r\n$ ", { now: 3503 }),
+    { accepted: true, data: "^C\r\n$ ", droppedBytes: 0, reason: "interrupt-echo" },
+  );
+});
+
+test("prompt gap keeps only the prompt suffix and drops stale prefix", () => {
+  const session = {};
+
+  armTerminalInterruptOutputGate(session, {
+    now: 3600,
+    quietMs: 500,
+    promptQuietMs: 80,
+    maxDrainMs: 1000,
+  });
+
+  assert.equal(filterTerminalInterruptOutput(session, "old output", { now: 3601 }).accepted, false);
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "stale flood\r\n$ ", { now: 3700 }),
+    { accepted: true, data: "$ ", droppedBytes: 13, reason: "prompt-gap" },
+  );
+});
+
+test("preserves alternate-screen exit controls while draining stale output", () => {
+  const session = {};
+
+  armTerminalInterruptOutputGate(session, {
+    now: 3800,
+    quietMs: 500,
+    promptQuietMs: 80,
+    maxDrainMs: 1000,
+  });
+
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "stale frame\x1b[?1049l", { now: 3801 }),
+    {
+      accepted: true,
+      data: "\x1b[?1049l",
+      droppedBytes: "stale frame".length,
+      reason: "draining",
+    },
+  );
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "more stale\x1b[?25h\r\n$ ", { now: 3900 }),
+    {
+      accepted: true,
+      data: "\x1b[?25h$ ",
+      droppedBytes: "more stale\r\n".length,
+      reason: "prompt-gap",
+    },
+  );
+});
+
+test("excludes preserved restore controls from held password prefixes", () => {
+  const session = {};
+
+  armTerminalInterruptOutputGate(session, {
+    now: 3850,
+    quietMs: 500,
+    promptQuietMs: 80,
+    maxDrainMs: 2500,
+  });
+
+  // Restore sequence is preserved once; password prefix hold must not re-count
+  // it, or stale bytes report as 0 dropped and the restore is re-emitted.
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "stale\n\x1b[?1049lPass", { now: 3851 }),
+    {
+      accepted: true,
+      data: "\x1b[?1049l",
+      droppedBytes: "stale\n".length,
+      reason: "draining",
+    },
+  );
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "word: ", { now: 3852 }),
+    {
+      accepted: true,
+      data: "Password: ",
+      droppedBytes: 0,
+      reason: "prompt-gap",
+    },
+  );
+});
+
+test("excludes the last of multiple preserved restores from held password prefixes", () => {
+  const session = {};
+
+  armTerminalInterruptOutputGate(session, {
+    now: 3855,
+    quietMs: 500,
+    promptQuietMs: 80,
+    maxDrainMs: 2500,
+  });
+
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "\x1b[?25hstale\n\x1b[?1049lPass", { now: 3856 }),
+    {
+      accepted: true,
+      data: "\x1b[?25h\x1b[?1049l",
+      droppedBytes: "stale\n".length,
+      reason: "draining",
+    },
+  );
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "word: ", { now: 3857 }),
+    {
+      accepted: true,
+      data: "Password: ",
+      droppedBytes: 0,
+      reason: "prompt-gap",
+    },
+  );
+});
+
+test("does not peel preserved restore suffix chars from a later password prefix", () => {
+  const session = {};
+
+  armTerminalInterruptOutputGate(session, {
+    now: 3860,
+    quietMs: 500,
+    promptQuietMs: 80,
+    maxDrainMs: 2500,
+  });
+
+  // Preserve restore on its own line; next line "login pass" must keep the "l".
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "\x1b[?1049l\nlogin pass", { now: 3861 }),
+    {
+      accepted: true,
+      data: "\x1b[?1049l",
+      droppedBytes: 1,
+      reason: "draining",
+    },
+  );
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "word: ", { now: 3862 }),
+    {
+      accepted: true,
+      data: "login password: ",
+      droppedBytes: 0,
+      reason: "prompt-gap",
+    },
+  );
+});
+
+test("does not leak held incomplete SGR CSI into a later shell prompt", () => {
+  const session = {};
+
+  armTerminalInterruptOutputGate(session, {
+    now: 3950,
+    quietMs: 500,
+    promptQuietMs: 80,
+    maxDrainMs: 2500,
+  });
+
+  // Incomplete SGR without a password prefix must be dropped, not held into "$ ".
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "old\x1b[31", { now: 3951 }),
+    {
+      accepted: false,
+      data: "",
+      droppedBytes: "old\x1b[31".length,
+      reason: "draining",
+    },
+  );
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "$ ", { now: 4100 }),
+    {
+      accepted: true,
+      data: "$ ",
+      droppedBytes: 0,
+      reason: "prompt-gap",
+    },
+  );
+});
+
+test("preserves split alternate-screen exit controls while draining stale output", () => {
+  const session = {};
+
+  armTerminalInterruptOutputGate(session, {
+    now: 4800,
+    quietMs: 500,
+    promptQuietMs: 80,
+    maxDrainMs: 1000,
+  });
+
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "stale frame\x1b[?104", { now: 4801 }),
+    {
+      accepted: false,
+      data: "",
+      droppedBytes: "stale frame".length,
+      reason: "draining",
+    },
+  );
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "9l^C\r\n$ ", { now: 4802 }),
+    {
+      accepted: true,
+      data: "\x1b[?1049l^C\r\n$ ",
+      droppedBytes: 0,
+      reason: "interrupt-echo",
+    },
+  );
+});
+
+test("does not preserve unsafe combined private modes while draining stale output", () => {
+  const session = {};
+
+  armTerminalInterruptOutputGate(session, {
+    now: 4900,
+    quietMs: 500,
+    promptQuietMs: 80,
+    maxDrainMs: 1000,
+  });
+
+  const unsafeSequence = "\x1b[?1049;25h";
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, `stale frame${unsafeSequence}^C\r\n$ `, {
+      now: 4901,
+    }),
+    {
+      accepted: true,
+      data: "^C\r\n$ ",
+      droppedBytes: "stale frame".length + unsafeSequence.length,
+      reason: "interrupt-echo",
+    },
+  );
+});
+
+test("accepts prompt candidates with OSC title and spaces after stale output", () => {
+  const session = {};
+
+  armTerminalInterruptOutputGate(session, {
+    now: 5000,
+    quietMs: 500,
+    promptQuietMs: 80,
+    maxDrainMs: 1000,
+  });
+
+  assert.equal(filterTerminalInterruptOutput(session, "old output", { now: 5001 }).accepted, false);
+  const prompt = "\x1b]0;~/My Project\x07~/My Project$ ";
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, prompt, { now: 5100 }),
+    {
+      accepted: true,
+      data: prompt,
+      droppedBytes: 0,
+      reason: "prompt-gap",
+    },
+  );
+});
+
+test("accepts split OSC prompt candidates after stale output", () => {
+  const session = {};
+
+  armTerminalInterruptOutputGate(session, {
+    now: 5200,
+    quietMs: 500,
+    promptQuietMs: 80,
+    maxDrainMs: 1000,
+  });
+
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "old output\x1b]0;~/My ", { now: 5201 }),
+    {
+      accepted: false,
+      data: "",
+      droppedBytes: "old output".length,
+      reason: "draining",
+    },
+  );
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "Project\x07~/My Project$ ", { now: 5300 }),
+    {
+      accepted: true,
+      data: "\x1b]0;~/My Project\x07~/My Project$ ",
+      droppedBytes: 0,
+      reason: "prompt-gap",
+    },
+  );
+});
+
+test("keeps draining large chunks after a short quiet gap", () => {
+  const session = {};
+
+  armTerminalInterruptOutputGate(session, {
+    now: 3000,
+    quietMs: 500,
+    promptQuietMs: 80,
+    maxDrainMs: 1000,
+  });
+
+  assert.equal(filterTerminalInterruptOutput(session, "old output", { now: 3001 }).accepted, false);
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "x".repeat(32768), { now: 3100 }),
+    { accepted: false, data: "", droppedBytes: 32768, reason: "draining" },
+  );
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "$ ", { now: 3200 }),
+    { accepted: true, data: "$ ", droppedBytes: 0, reason: "prompt-gap" },
+  );
+});
+
+test("accepts a sudo password prompt while draining after Ctrl+C (#2010)", () => {
+  const session = {};
+
+  armTerminalInterruptOutputGate(session, {
+    now: 6000,
+    quietMs: 500,
+    promptQuietMs: 80,
+    maxDrainMs: 2500,
+  });
+
+  assert.equal(
+    filterTerminalInterruptOutput(session, "Reading package lists...\n", { now: 6001 }).accepted,
+    false,
+  );
+  // One-chunk password prompts must resume before promptQuietMs — they often
+  // emit nothing further until the user types (#2010 / Codex P1).
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "[sudo] password for alice: ", { now: 6010 }),
+    {
+      accepted: true,
+      data: "[sudo] password for alice: ",
+      droppedBytes: 0,
+      reason: "password-prompt",
+    },
+  );
+});
+
+test("accepts bare and localized password prompts while draining (#2010)", () => {
+  for (const prompt of [
+    "Password: ",
+    "[sudo] alice 的密码：",
+    "输入密码",
+    "Input Password",
+    "用户 的密码",
+    "密码",
+  ]) {
+    const session = {};
+    armTerminalInterruptOutputGate(session, {
+      now: 7000,
+      quietMs: 500,
+      promptQuietMs: 80,
+      maxDrainMs: 2500,
+    });
+    assert.equal(filterTerminalInterruptOutput(session, "stale\n", { now: 7001 }).accepted, false);
+    assert.deepEqual(
+      filterTerminalInterruptOutput(session, prompt, { now: 7010 }),
+      {
+        accepted: true,
+        data: prompt,
+        droppedBytes: 0,
+        reason: "password-prompt",
+      },
+      `expected password prompt to resume drain: ${JSON.stringify(prompt)}`,
+    );
+  }
+});
+
+test("does not treat password mentions in ordinary output as prompts", () => {
+  const session = {};
+
+  armTerminalInterruptOutputGate(session, {
+    now: 8000,
+    quietMs: 500,
+    promptQuietMs: 80,
+    maxDrainMs: 2500,
+  });
+
+  assert.equal(filterTerminalInterruptOutput(session, "stale\n", { now: 8001 }).accepted, false);
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "the password was changed", { now: 8100 }),
+    { accepted: false, data: "", droppedBytes: 24, reason: "draining" },
+  );
+});
+
+test("holds a split Password: prompt across chunks while draining (#2010)", () => {
+  const session = {};
+
+  armTerminalInterruptOutputGate(session, {
+    now: 9000,
+    quietMs: 500,
+    promptQuietMs: 80,
+    maxDrainMs: 2500,
+  });
+
+  assert.equal(filterTerminalInterruptOutput(session, "stale\n", { now: 9001 }).accepted, false);
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "Pass", { now: 9002 }),
+    { accepted: false, data: "", droppedBytes: 0, reason: "draining" },
+  );
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "word: ", { now: 9003 }),
+    {
+      accepted: true,
+      data: "Password: ",
+      droppedBytes: 0,
+      reason: "prompt-gap",
+    },
+  );
+});
+
+test("holds a split ANSI-colored Password: prompt across chunks while draining", () => {
+  const session = {};
+  const red = "\x1b[31m";
+  const reset = "\x1b[0m";
+
+  armTerminalInterruptOutputGate(session, {
+    now: 9050,
+    quietMs: 500,
+    promptQuietMs: 80,
+    maxDrainMs: 2500,
+  });
+
+  assert.equal(filterTerminalInterruptOutput(session, "stale\n", { now: 9051 }).accepted, false);
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, `${red}Pass`, { now: 9052 }),
+    { accepted: false, data: "", droppedBytes: 0, reason: "draining" },
+  );
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, `word:${reset} `, { now: 9053 }),
+    {
+      accepted: true,
+      data: `${red}Password:${reset} `,
+      droppedBytes: 0,
+      reason: "prompt-gap",
+    },
+  );
+});
+
+test("holds a password prefix split before a trailing ANSI control while draining", () => {
+  const session = {};
+  const red = "\x1b[31m";
+  const reset = "\x1b[0m";
+
+  armTerminalInterruptOutputGate(session, {
+    now: 9070,
+    quietMs: 500,
+    promptQuietMs: 80,
+    maxDrainMs: 2500,
+  });
+
+  assert.equal(filterTerminalInterruptOutput(session, "stale\n", { now: 9071 }).accepted, false);
+  // Mid-CSI split: keep both "Pass" and the trailing "\x1b[" so the next chunk
+  // can complete the reset + "word:" into a password prompt.
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, `${red}Pass\x1b[`, { now: 9072 }),
+    { accepted: false, data: "", droppedBytes: 0, reason: "draining" },
+  );
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, `0mword: `, { now: 9073 }),
+    {
+      accepted: true,
+      data: `${red}Pass${reset}word: `,
+      droppedBytes: 0,
+      reason: "prompt-gap",
+    },
+  );
+});
+
+test("holds a password prefix split mid CSI parameter while draining", () => {
+  const session = {};
+  const red = "\x1b[31m";
+  const reset = "\x1b[0m";
+
+  armTerminalInterruptOutputGate(session, {
+    now: 9080,
+    quietMs: 500,
+    promptQuietMs: 80,
+    maxDrainMs: 2500,
+  });
+
+  assert.equal(filterTerminalInterruptOutput(session, "stale\n", { now: 9081 }).accepted, false);
+  // Incomplete CSI params (ESC[0) must also hold with the password prefix.
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, `${red}Pass\x1b[0`, { now: 9082 }),
+    { accepted: false, data: "", droppedBytes: 0, reason: "draining" },
+  );
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, `mword: `, { now: 9083 }),
+    {
+      accepted: true,
+      data: `${red}Pass${reset}word: `,
+      droppedBytes: 0,
+      reason: "prompt-gap",
+    },
+  );
+});
+
+test("holds a split [sudo] password prompt across chunks while draining (#2010)", () => {
+  const session = {};
+
+  armTerminalInterruptOutputGate(session, {
+    now: 9100,
+    quietMs: 500,
+    promptQuietMs: 80,
+    maxDrainMs: 2500,
+  });
+
+  assert.equal(filterTerminalInterruptOutput(session, "stale\n", { now: 9101 }).accepted, false);
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "[sudo] pass", { now: 9102 }),
+    { accepted: false, data: "", droppedBytes: 0, reason: "draining" },
+  );
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "word for alice: ", { now: 9103 }),
+    {
+      accepted: true,
+      data: "[sudo] password for alice: ",
+      droppedBytes: 0,
+      reason: "prompt-gap",
+    },
+  );
+});
+
+test("discards a held password prefix that does not complete as a password prompt", () => {
+  const session = {};
+
+  armTerminalInterruptOutputGate(session, {
+    now: 9200,
+    quietMs: 500,
+    promptQuietMs: 80,
+    maxDrainMs: 2500,
+  });
+
+  assert.equal(filterTerminalInterruptOutput(session, "stale\n", { now: 9201 }).accepted, false);
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "Pass", { now: 9202 }),
+    { accepted: false, data: "", droppedBytes: 0, reason: "draining" },
+  );
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "$ ", { now: 9400 }),
+    {
+      accepted: true,
+      data: "$ ",
+      droppedBytes: 4,
+      reason: "prompt-gap",
+    },
+  );
+});
+
+test("discards CSI final bytes when a held mid-CSI password prefix does not complete", () => {
+  const session = {};
+
+  armTerminalInterruptOutputGate(session, {
+    now: 9220,
+    quietMs: 500,
+    promptQuietMs: 80,
+    maxDrainMs: 2500,
+  });
+
+  assert.equal(filterTerminalInterruptOutput(session, "stale\n", { now: 9221 }).accepted, false);
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "Pass\x1b[0", { now: 9222 }),
+    { accepted: false, data: "", droppedBytes: 0, reason: "draining" },
+  );
+  // Discard held prefix and the completing "m" so the shell prompt is clean.
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "m$ ", { now: 9400 }),
+    {
+      accepted: true,
+      data: "$ ",
+      droppedBytes: "Pass\x1b[0".length + 1,
+      reason: "prompt-gap",
+    },
+  );
+});
+
+test("does not hold ordinary password-related output as a prompt prefix", () => {
+  const session = {};
+
+  armTerminalInterruptOutputGate(session, {
+    now: 9300,
+    quietMs: 500,
+    promptQuietMs: 80,
+    maxDrainMs: 2500,
+  });
+
+  assert.equal(filterTerminalInterruptOutput(session, "stale\n", { now: 9301 }).accepted, false);
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "Password authentication failed", { now: 9302 }),
+    {
+      accepted: false,
+      data: "",
+      droppedBytes: "Password authentication failed".length,
+      reason: "draining",
+    },
+  );
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "$ ", { now: 9500 }),
+    {
+      accepted: true,
+      data: "$ ",
+      droppedBytes: 0,
+      reason: "prompt-gap",
+    },
+  );
+});
+
+test("holds split password prompts that have leading text before the keyword", () => {
+  const ssh = {};
+  armTerminalInterruptOutputGate(ssh, {
+    now: 9600,
+    quietMs: 500,
+    promptQuietMs: 80,
+    maxDrainMs: 2500,
+  });
+  assert.equal(filterTerminalInterruptOutput(ssh, "stale\n", { now: 9601 }).accepted, false);
+  assert.deepEqual(
+    filterTerminalInterruptOutput(ssh, "alice@host's pass", { now: 9602 }),
+    { accepted: false, data: "", droppedBytes: 0, reason: "draining" },
+  );
+  assert.deepEqual(
+    filterTerminalInterruptOutput(ssh, "word: ", { now: 9603 }),
+    {
+      accepted: true,
+      data: "alice@host's password: ",
+      droppedBytes: 0,
+      reason: "prompt-gap",
+    },
+  );
+
+  const kylin = {};
+  armTerminalInterruptOutputGate(kylin, {
+    now: 9700,
+    quietMs: 500,
+    promptQuietMs: 80,
+    maxDrainMs: 2500,
+  });
+  assert.equal(filterTerminalInterruptOutput(kylin, "stale\n", { now: 9701 }).accepted, false);
+  assert.deepEqual(
+    filterTerminalInterruptOutput(kylin, "用户 的密", { now: 9702 }),
+    { accepted: false, data: "", droppedBytes: 0, reason: "draining" },
+  );
+  assert.deepEqual(
+    filterTerminalInterruptOutput(kylin, "码", { now: 9703 }),
+    {
+      accepted: true,
+      data: "用户 的密码",
+      droppedBytes: 0,
+      reason: "prompt-gap",
+    },
+  );
+});
+
+test("accepts a fresh one-chunk password prompt before the quiet gap", () => {
+  const session = {};
+
+  armTerminalInterruptOutputGate(session, {
+    now: 9800,
+    quietMs: 500,
+    promptQuietMs: 80,
+    maxDrainMs: 2500,
+  });
+
+  assert.equal(filterTerminalInterruptOutput(session, "old flood\n", { now: 9801 }).accepted, false);
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "Password: ", { now: 9810 }),
+    {
+      accepted: true,
+      data: "Password: ",
+      droppedBytes: 0,
+      reason: "password-prompt",
+    },
+  );
+});
+
+test("accepts a last-line password prompt after a large stale prefix", () => {
+  const session = {};
+
+  armTerminalInterruptOutputGate(session, {
+    now: 9820,
+    quietMs: 500,
+    promptQuietMs: 80,
+    maxDrainMs: 2500,
+    promptCandidateBytes: 512,
+  });
+
+  assert.equal(filterTerminalInterruptOutput(session, "stale\n", { now: 9821 }).accepted, false);
+  const largeChunk = `${"x".repeat(600)}\n[sudo] password for alice: `;
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, largeChunk, { now: 9830 }),
+    {
+      accepted: true,
+      data: "[sudo] password for alice: ",
+      droppedBytes: 601,
+      reason: "password-prompt",
+    },
+  );
+});
+
+test("does not hold short ASCII trailing letters as password prefixes", () => {
+  const session = {};
+
+  armTerminalInterruptOutputGate(session, {
+    now: 10000,
+    quietMs: 500,
+    promptQuietMs: 80,
+    maxDrainMs: 2500,
+  });
+
+  assert.equal(filterTerminalInterruptOutput(session, "stale\n", { now: 10001 }).accepted, false);
+  // Full-width "password：" must not lower ASCII minLen to 1, or "copy p" is held
+  // and a later "assword:" chunk can bypass quiet-gap.
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "copy p", { now: 10002 }),
+    {
+      accepted: false,
+      data: "",
+      droppedBytes: "copy p".length,
+      reason: "draining",
+    },
+  );
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "assword: ", { now: 10010 }),
+    {
+      accepted: false,
+      data: "",
+      droppedBytes: "assword: ".length,
+      reason: "draining",
+    },
+  );
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "$ ", { now: 10200 }),
+    {
+      accepted: true,
+      data: "$ ",
+      droppedBytes: 0,
+      reason: "prompt-gap",
+    },
+  );
+});
+
+test("rejects held password-prefix completion across a line break", () => {
+  const session = {};
+
+  armTerminalInterruptOutputGate(session, {
+    now: 9900,
+    quietMs: 500,
+    promptQuietMs: 80,
+    maxDrainMs: 2500,
+  });
+
+  assert.equal(filterTerminalInterruptOutput(session, "stale\n", { now: 9901 }).accepted, false);
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "Pass", { now: 9902 }),
+    { accepted: false, data: "", droppedBytes: 0, reason: "draining" },
+  );
+  // A newline before Password: discards the held "Pass" prefix (not a same-line
+  // completion), but the fresh complete password line is still preserved.
+  assert.deepEqual(
+    filterTerminalInterruptOutput(session, "\nPassword: ", { now: 9910 }),
+    {
+      accepted: true,
+      data: "Password: ",
+      droppedBytes: 4 + 1,
+      reason: "password-prompt",
+    },
+  );
+});