diff --git a/docs/docs/configure/warehouses.md b/docs/docs/configure/warehouses.md
index 6f00f056e3..71b254ce21 100644
--- a/docs/docs/configure/warehouses.md
+++ b/docs/docs/configure/warehouses.md
@@ -24,7 +24,7 @@ Each warehouse has a key (the connection name) and a config object:
     Use `{env:...}` substitution for passwords and tokens so you never commit secrets to version control.
 
 !!! note "Where saved passwords go"
-    When the agent adds a connection for you, passwords, keys and tokens are kept in your OS credential store (macOS Keychain, Windows Credential Manager, or libsecret on Linux), never in `connections.json`. If no credential store is available, the credential is not saved: the connection works for that session only, and Altimate Code says so. Use an `ALTIMATE_CODE_CONN_<NAME>` environment variable instead in that case. Removing a connection removes its credentials from the store, and saving a connection again under the same name drops credentials it no longer uses.
+    When the agent adds a connection for you, passwords, keys and tokens are kept in your OS credential store (macOS Keychain, Windows Credential Manager, or libsecret on Linux), never in `connections.json`. If no credential store is available, the credential is not saved: the connection works for that session only, and Altimate Code says so. In that case set an `ALTIMATE_CODE_CONN_<NAME>` environment variable to the connection's full config as JSON (not just the password); for a name containing `-`, set it with `env`, since a shell assignment cannot use that character. Removing a saved connection removes its credentials from the store, unless this project's connections file or an environment variable still defines a connection by that name. Saving a connection again under the same name drops the credentials it no longer uses once the new config is written. Credentials are stored by connection name, so a project file that defines a connection of the same name without its own password was using the saved connection's, and loses it when that one is removed. If the store refuses a removal, Altimate Code says which credentials remain.
 
 ## Snowflake
 
@@ -53,7 +53,7 @@ Each warehouse has a key (the connection name) and a config object:
 | `database` | No | Database name |
 | `schema` | No | Schema name |
 | `role` | No | User role |
-| `client_session_keep_alive` | No | Keep the session alive while Altimate Code is running (default `true`). A connection Snowflake closes anyway is reopened automatically. A read-only query interrupted by the close is run again; a statement that changes data is not, because it may already have run, and the error says so. After a reopen, `USE` and `ALTER SESSION` settings must be run again. |
+| `client_session_keep_alive` | No | Keep the session alive while Altimate Code is running (default `true`). A connection Snowflake closes anyway is reopened automatically. `USE`, `ALTER SESSION` and `SET` settings are applied again to the reopened session. A single read-only query interrupted by the close is run again; a statement that changes data, or calls a sequence, is not, because it may already have run, and the error says so. Temporary tables and an open transaction cannot be restored: statements issued before the reopen report that instead of running. |
 
 ### Key-pair authentication
 
diff --git a/docs/docs/reference/troubleshooting.md b/docs/docs/reference/troubleshooting.md
index 6facc8dc7d..1b9cc07500 100644
--- a/docs/docs/reference/troubleshooting.md
+++ b/docs/docs/reference/troubleshooting.md
@@ -265,11 +265,11 @@ In debug mode the log records every tool call as it starts and ends, and while o
 altimate debug bundle
 ```
 
-This writes `altimate-debug-report-<time>.md` in the current folder (use `--output <path>` to choose another place). It lists the problems it detected first, then the evidence: version and install method, operating system and terminal, warehouse connections (names, types, sign-in method and which fields are set, never values), MCP servers, a summary of the log, and the last 300 log lines. It also checks that the Snowflake and Databricks warehouses, the Altimate API, the telemetry endpoint (when telemetry is on) and the model catalogue this installation uses are reachable over HTTPS. Add `--no-network` and the command makes no network requests at all, telemetry included. It does not start your project (plugins, language servers), so it still works when that is what hangs. The file is readable only by you.
+This writes `altimate-debug-report-<time>.md` in the current folder (use `--output <path>` to choose another place). It lists the problems it detected first, then the evidence: version and install method, operating system and terminal, warehouse connections (names, types, sign-in method and which fields are set, never values), MCP servers, a summary of the log, and the last 300 log lines. It also checks that the Snowflake and Databricks warehouses, the Altimate API, the telemetry endpoint (when telemetry is on) and the model catalogue this installation uses are reachable over HTTPS. Add `--no-network` (or `--network=false`) and the command makes no network requests at all, telemetry included. It does not start your project (plugins, language servers), so it still works when that is what hangs. The file is created readable only by you, where the filesystem supports it.
 
-Passwords, keys, tokens and other secret settings (in any `name=value`, JSON or connection-URL form), email addresses, URL parameters, your home folder, your user name and your computer's name are removed. The report stays on your machine: read it, then send it to Altimate support yourself.
+Passwords, keys, tokens and other secret settings (in `name=value`, JSON and connection-URL forms), email addresses, URL parameters, your home folder, your user name and your computer's name are removed. This is pattern-based and can miss a secret in an unusual format, so read the report before you send it. It stays on your machine until you send it to Altimate support yourself.
 
-For raw logs printed to the terminal instead:
+To save the raw logs to a file instead:
 
 ```bash
 altimate --print-logs --log-level DEBUG 2>debug.log
diff --git a/packages/drivers/src/snowflake.ts b/packages/drivers/src/snowflake.ts
index 12b386cf0d..0284c8263f 100644
--- a/packages/drivers/src/snowflake.ts
+++ b/packages/drivers/src/snowflake.ts
@@ -78,9 +78,10 @@ function stripLeadingComments(sql: string): string {
   }
 }
 
-/** Keywords that change data, objects or the session, anywhere in a statement. */
+/** Keywords that change data, objects or the session, anywhere in a statement. Sequence generators and SYSTEM$
+ * functions are included: `SELECT seq.NEXTVAL` advances a sequence, and several SYSTEM$ functions act. */
 const WRITE_KEYWORDS =
-  /\b(INSERT|UPDATE|DELETE|MERGE|CREATE|DROP|ALTER|TRUNCATE|COPY|CALL|PUT|GET|REMOVE|GRANT|REVOKE|UNDROP|EXECUTE|BEGIN|COMMIT|ROLLBACK|SET|UNSET|USE)\b/i
+  /\b(INSERT|UPDATE|DELETE|MERGE|CREATE|DROP|ALTER|TRUNCATE|COPY|CALL|PUT|GET|REMOVE|GRANT|REVOKE|UNDROP|EXECUTE|BEGIN|COMMIT|ROLLBACK|SET|UNSET|USE|NEXTVAL|GETNEXTVAL)\b|SYSTEM\$/i
 
 /**
  * True when sending `sql` a second time cannot change anything: a single
@@ -98,14 +99,59 @@ export function isRetrySafe(sql: string): boolean {
   return false
 }
 
-/** Statements whose effect lives in the session (current database/schema/role, session parameters, variables,
- * temporary objects, an open transaction) and is lost when the session is replaced. */
-export function changesSession(sql: string): boolean {
+/** The statement with string literals emptied, so a `;` or keyword inside a literal is not mistaken for SQL. */
+function withoutLiterals(sql: string): string {
+  return stripLeadingComments(sql).replace(/'(?:[^']|'')*'/g, "''").replace(/;\s*$/, "")
+}
+
+/** Starts like a session-scoped change: current database/schema/role/warehouse, a parameter or a variable. */
+function looksLikeSessionChange(sql: string): boolean {
+  return /^(USE|SET|UNSET|ALTER\s+SESSION)\b/i.test(stripLeadingComments(sql))
+}
+
+/**
+ * A session setting that can be applied again to a new session with the same effect: one statement, with no
+ * subquery, sequence or SYSTEM$ call in it. `SET v = (SELECT seq.NEXTVAL)` is a setting, but replaying it would
+ * consume another value, so it is not one of these.
+ */
+export function isSessionSetting(sql: string): boolean {
+  if (!looksLikeSessionChange(sql)) return false
+  const s = withoutLiterals(sql)
+  return !s.includes(";") && !/\(\s*SELECT\b|\bNEXTVAL\b|\bGETNEXTVAL\b|SYSTEM\$/i.test(s)
+}
+
+/** Opens a transaction, which a new session does not have. */
+function opensTransaction(sql: string): boolean {
+  return /^(BEGIN|START\s+TRANSACTION)\b/i.test(stripLeadingComments(sql))
+}
+
+/** Ends the open transaction. */
+function endsTransaction(sql: string): boolean {
+  return /^(COMMIT|ROLLBACK)\b/i.test(stripLeadingComments(sql))
+}
+
+/**
+ * Session state that cannot be re-created by replaying a statement: temporary objects, an open transaction, and
+ * session changes that are not safe to replay (several statements in one, or a value computed with side effects).
+ */
+export function holdsSessionState(sql: string): boolean {
   const s = stripLeadingComments(sql)
-  return /^(USE|SET|UNSET|BEGIN|START\s+TRANSACTION|ALTER\s+SESSION)\b/i.test(s) ||
-    /^CREATE\s+(OR\s+REPLACE\s+)?(LOCAL\s+|GLOBAL\s+)?(TEMP|TEMPORARY|VOLATILE)\b/i.test(s)
+  return opensTransaction(sql) ||
+    /^CREATE\s+(OR\s+REPLACE\s+)?(LOCAL\s+|GLOBAL\s+)?(TEMP|TEMPORARY|VOLATILE)\b/i.test(s) ||
+    (looksLikeSessionChange(sql) && !isSessionSetting(sql))
 }
 
+/** Either kind: a statement whose effect lives only in the session. */
+export function changesSession(sql: string): boolean {
+  return isSessionSetting(sql) || holdsSessionState(sql)
+}
+
+/** Cap on remembered session settings; past it the session is treated as not replayable. */
+const MAX_SESSION_SETTINGS = 100
+
+/** Replay passes before settings that keep arriving during a reconnect are given up on. */
+const MAX_REPLAY_PASSES = 5
+
 /** `client_session_keep_alive` / `clientSessionKeepAlive`; on unless explicitly false. */
 export function keepAliveSetting(config: ConnectionConfig): boolean {
   const value = config.client_session_keep_alive ?? config.clientSessionKeepAlive
@@ -154,8 +200,20 @@ export async function connect(
   let reconnecting: Promise<void> | undefined
   /** Set by close(): a reconnect that finishes afterwards must not install a session nobody will close. */
   let closed = false
-  /** A statement changed session state, which a reconnect silently drops; such a session's statements are not resent. */
-  let sessionChanged = false
+  /** Session settings that succeeded, in order, replayed onto every reopened connection before it is used. */
+  const sessionSettings: string[] = []
+  /** Counts installed connections. A statement remembers the generation it started in. */
+  let generation = 0
+  /** Counts explicit `connect()` calls. A result from before the latest one belongs to a session the caller chose to
+   * replace, and is never carried onto the fresh one. */
+  let epoch = 0
+  /** The generation whose session holds state that cannot be replayed: temporary objects or unreplayable settings
+   * (`tempIn`), and an open transaction (`txnIn`, cleared by COMMIT/ROLLBACK). */
+  let tempIn: number | undefined
+  let txnIn: number | undefined
+  /** The generation at which that state was lost: statements that started before it are not run, because they
+   * may depend on it; statements issued after it run on the new session. Never cleared by a late error. */
+  let stateLostAt: number | undefined
 
   function openConnection(): Promise<any> {
     const account = connectOptions?.account
@@ -236,15 +294,51 @@ export async function connect(
     if (!reconnecting) {
       const previous = connection
       reconnecting = openConnection()
-        .then((conn) => {
-          if (closed) {
+        .then(async (conn) => {
+          const discard = () => {
             try {
               conn.destroy?.(() => {})
             } catch {
               // nothing to release
             }
+          }
+          // The session's settings are restored before anyone can use the connection, so every caller waiting on
+          // this reconnect runs with them. Each pass replays a snapshot (a late setting may reorder the live list
+          // mid-pass); a setting that completed on the old connection during a pass changes the list, so the list is
+          // replayed again until a pass ends with it unchanged. Settings are safe to apply twice. Nothing awaits
+          // between the last check and installing the connection below, so none can slip in after it.
+          for (let pass = 0; ; pass++) {
+            const snapshot = [...sessionSettings]
+            for (const setting of snapshot) {
+              try {
+                await runQuery(conn, setting)
+              } catch (err) {
+                discard()
+                throw new Error(
+                  `Snowflake closed the session and its settings could not be restored on a new one (${setting}): ${(err as Error)?.message ?? err}`,
+                )
+              }
+            }
+            const unchanged = snapshot.length === sessionSettings.length && snapshot.every((v, i) => v === sessionSettings[i])
+            if (unchanged) break
+            if (pass + 1 >= MAX_REPLAY_PASSES) {
+              // Settings keep arriving: a connection installed now would run later queries with some of them missing.
+              discard()
+              throw new Error(
+                "Snowflake closed the session and it could not be restored on a new one: session settings kept changing while they were being restored. Try again.",
+              )
+            }
+          }
+          if (closed) {
+            discard()
             throw new Error("Snowflake connection was closed while reconnecting")
           }
+          generation++
+          if (tempIn !== undefined || txnIn !== undefined) {
+            stateLostAt = generation
+            tempIn = undefined
+            txnIn = undefined
+          }
           connection = conn
           suppressSnowflakeLogging(snowflake)
           try {
@@ -260,25 +354,63 @@ export async function connect(
     return reconnecting
   }
 
-  /** The error for a statement held back because the replaced session had state it depended on. Reported once:
-   * the reopened session starts clean, so later statements run as usual. */
+  /** For a statement that started before the session holding temporary objects or a transaction was replaced. */
   function sessionLostError(cause: string): Error {
-    sessionChanged = false
     return new Error(
-      `Snowflake closed the session (${cause}), and its USE, ALTER SESSION, variables or temporary objects went with it, ` +
-        `so this statement was not run on the new session. The connection has been reopened; run those statements again first.`,
+      `Snowflake closed the session (${cause}), and its temporary objects or open transaction went with it, ` +
+        `so this statement was not run on the new session. The connection has been reopened (session settings were restored); ` +
+        `re-create what the statement depends on, then run it again.`,
     )
   }
 
+  /** Whether a statement that started in generation `started` may depend on state that has since been lost. */
+  function lostFor(started: number): boolean {
+    return stateLostAt !== undefined && started < stateLostAt
+  }
+
   /** Reopen before use when the SDK already knows the connection is gone (idle timeout, network drop, sleep). */
   async function ensureLive(): Promise<void> {
     if (reconnecting) return reconnecting
     if (connection && connectOptions && typeof connection.isUp === "function" && !connection.isUp()) {
       await reconnect()
-      if (sessionChanged) throw sessionLostError("it had expired")
     }
   }
 
+  /**
+   * Remember what a successful statement did to the session. `ranIn` is the generation it ran in: when another
+   * statement has replaced the connection meanwhile, its effect is on a session that is gone. A late setting is
+   * applied to the current session too; late state that cannot be replayed is reported to its caller.
+   */
+  async function noteSession(sql: string, binds: any[] | undefined, ranIn: number, ranInEpoch: number): Promise<void> {
+    const replayable = isSessionSetting(sql) && !(binds && binds.length)
+    // From before an explicit connect(): that session was replaced on purpose; nothing of it carries over.
+    if (ranInEpoch !== epoch) return
+    if (ranIn !== generation) {
+      if (replayable) {
+        // Not remembered (the list is full): the setting cannot be restored by a later reconnect.
+        if (!rememberSetting(sql)) tempIn = generation
+        await runQuery(connection, sql)
+      } else if (holdsSessionState(sql) || (looksLikeSessionChange(sql) && !replayable)) {
+        throw sessionLostError("it was replaced while this statement ran")
+      }
+      return
+    }
+    if (endsTransaction(sql)) txnIn = undefined
+    else if (opensTransaction(sql)) txnIn = ranIn
+    else if (replayable) {
+      if (!rememberSetting(sql)) tempIn = ranIn
+    } else if (holdsSessionState(sql) || looksLikeSessionChange(sql)) tempIn = ranIn
+  }
+
+  /** Adds a setting to the replay list, once (a repeat moves it to the end); false when the list is full. */
+  function rememberSetting(sql: string): boolean {
+    const at = sessionSettings.indexOf(sql)
+    if (at >= 0) sessionSettings.splice(at, 1)
+    else if (sessionSettings.length >= MAX_SESSION_SETTINGS) return false
+    sessionSettings.push(sql)
+    return true
+  }
+
   function escapeSqlIdentifier(value: string): string {
     return value.replace(/"/g, '""')
   }
@@ -289,11 +421,16 @@ export async function connect(
    * it may already have run (see `isRetrySafe`).
    */
   async function executeQuery(sql: string, binds?: any[]): Promise<{ columns: string[]; rows: any[][] }> {
+    // Captured before any wait: a statement queued behind a reconnect started on the old session's assumptions.
+    const started = generation
+    const startedInEpoch = epoch
     await ensureLive()
+    if (lostFor(started)) throw sessionLostError("it had expired")
     const used = connection
+    const ranIn = generation
     try {
       const result = await runQuery(used, sql, binds)
-      if (changesSession(sql)) sessionChanged = true
+      await noteSession(sql, binds, ranIn, startedInEpoch)
       return result
     } catch (err) {
       if (!connectOptions || !isClosedConnectionError(err)) throw err
@@ -302,14 +439,18 @@ export async function connect(
       if (connection === used) await reconnect()
       else if (reconnecting) await reconnecting
       const cause = String((err as Error)?.message ?? err)
-      if (sessionChanged) throw sessionLostError(cause)
-      if (!isRetrySafe(sql)) {
+      if (lostFor(started)) throw sessionLostError(cause)
+      // A session setting is safe to apply twice, and must be applied for the statements that follow it.
+      if (!isRetrySafe(sql) && !isSessionSetting(sql)) {
         throw new Error(
           `Snowflake closed the session while this statement was running, so it was not run again: it may change data ` +
             `and could already have run. The connection has been reopened; check the result before running it again. (${cause})`,
         )
       }
-      return runQuery(connection, sql, binds)
+      const ranAgainIn = generation
+      const result = await runQuery(connection, sql, binds)
+      await noteSession(sql, binds, ranAgainIn, startedInEpoch)
+      return result
     }
   }
 
@@ -338,6 +479,13 @@ export async function connect(
   return {
     async connect() {
       closed = false
+      // A fresh session: nothing recorded for an earlier one applies to it.
+      sessionSettings.length = 0
+      tempIn = undefined
+      txnIn = undefined
+      stateLostAt = undefined
+      generation++
+      epoch++
       const options: Record<string, unknown> = {
         account: config.account,
         username: config.user ?? config.username,
diff --git a/packages/drivers/test/snowflake-reconnect.test.ts b/packages/drivers/test/snowflake-reconnect.test.ts
index c10eae117f..d7c92ef4a6 100644
--- a/packages/drivers/test/snowflake-reconnect.test.ts
+++ b/packages/drivers/test/snowflake-reconnect.test.ts
@@ -4,10 +4,24 @@
  * with "Unable to perform operation using terminated connection" until restart.
  */
 import { describe, test, expect } from "bun:test"
-import { changesSession, connect, isClosedConnectionError, isRetrySafe, keepAliveSetting } from "../src/snowflake"
+import { changesSession, connect, holdsSessionState, isClosedConnectionError, isRetrySafe, isSessionSetting, keepAliveSetting } from "../src/snowflake"
 
-type Failure = { code: unknown; message: string; delayMs?: number }
-type Behaviour = { up: boolean; failNextWith?: Failure; failQueue?: Failure[] }
+/** `after`: the failure is delivered only once this settles, so a test can order it against a reconnect. */
+type Failure = { code: unknown; message: string; delayMs?: number; after?: Promise<unknown> }
+/** `holdNext`: the next successful statement completes only once this settles (a statement still running on a
+ * connection another statement replaces meanwhile). */
+type Behaviour = {
+  up: boolean
+  failNextWith?: Failure
+  failQueue?: Failure[]
+  holdNext?: Promise<unknown>
+  /** Like `holdNext`, one per statement in order. */
+  holdQueue?: Promise<unknown>[]
+  /** Called with each statement this connection runs. */
+  onExecute?: (sql: string) => void
+  /** How long a successful statement takes on this connection (default 1 ms). */
+  delayMs?: number
+}
 
 /** A minimal stand-in for snowflake-sdk: records connections and lets a test close them. `gate`, when set, holds
  * every new connect() until the test calls it. */
@@ -16,12 +30,15 @@ function fakeSdk() {
   const held: Array<() => void> = []
   const sdk = {
     hold: false,
+    /** Applied to the state of the next connection created (e.g. to hold its first statement). */
+    nextState: undefined as Partial<Behaviour> | undefined,
     release() {
       for (const r of held.splice(0)) r()
     },
     configure() {},
     createConnection(options: any) {
-      const entry = { options, state: { up: true } as Behaviour, destroyed: false, executed: [] as string[] }
+      const entry = { options, state: { up: true, ...sdk.nextState } as Behaviour, destroyed: false, executed: [] as string[] }
+      sdk.nextState = undefined
       created.push(entry)
       return {
         connect(cb: (err: Error | null) => void) {
@@ -34,11 +51,18 @@ function fakeSdk() {
           if (f) {
             entry.state.failNextWith = undefined
             const err = Object.assign(new Error(f.message), { code: f.code })
-            setTimeout(() => opts.complete(err, null, []), f.delayMs ?? 1)
+            const deliver = () => setTimeout(() => opts.complete(err, null, []), f.delayMs ?? 1)
+            if (f.after) f.after.then(deliver)
+            else deliver()
             return
           }
           entry.executed.push(opts.sqlText)
-          setTimeout(() => opts.complete(null, null, [{ N: created.indexOf(entry) }]), 1)
+          entry.state.onExecute?.(opts.sqlText)
+          const hold = entry.state.holdNext ?? entry.state.holdQueue?.shift()
+          entry.state.holdNext = undefined
+          const done = () => setTimeout(() => opts.complete(null, null, [{ N: created.indexOf(entry) }]), entry.state.delayMs ?? 1)
+          if (hold) hold.then(done)
+          else done()
         },
         destroy(cb: (err: Error | null) => void) {
           entry.destroyed = true
@@ -114,16 +138,24 @@ describe("Snowflake connection lifecycle", () => {
     const { sdk, created } = fakeSdk()
     const c = await connect(config, sdk)
     await c.connect()
-    // Two statements in flight on the first connection; one fails at once, the other only after the reconnect.
+    // Two statements in flight on the first connection; one fails at once, the other only once the reconnect
+    // has completed (not after a guessed delay, so a paused event loop cannot reorder them).
+    let reconnected!: () => void
+    const reconnectDone = new Promise<void>((r) => (reconnected = r))
     created[0].state.failQueue = [
       { code: 407002, message: "terminated connection", delayMs: 1 },
-      { code: 407002, message: "terminated connection", delayMs: 40 },
+      { code: 407002, message: "terminated connection", after: reconnectDone },
     ]
-    const [a, b] = await Promise.all([c.execute("SELECT 1"), c.execute("SELECT 2")])
+    const a = c.execute("SELECT 1")
+    const bPromise = c.execute("SELECT 2")
+    await a
+    expect(created.length).toBe(2) // the reconnect for SELECT 1 is complete
+    reconnected()
+    const b = await bPromise
     expect(created.length).toBe(2)
     expect(created[1].destroyed).toBe(false)
     expect(created[1].executed).toEqual(["SELECT 1 LIMIT 1001", "SELECT 2 LIMIT 1001"])
-    expect(a.rows).toEqual([[1]])
+    expect((await a).rows).toEqual([[1]])
     expect(b.rows).toEqual([[1]])
   })
 
@@ -143,17 +175,235 @@ describe("Snowflake connection lifecycle", () => {
     expect(created[1].destroyed).toBe(true)
   })
 
-  test("a session that ran USE is not silently replaced: the next statement says so, then runs normally", async () => {
+  test("session settings are restored on the reopened session before anything runs on it", async () => {
     const { sdk, created } = fakeSdk()
     const c = await connect(config, sdk)
     await c.connect()
     await c.execute("USE SCHEMA analytics")
+    await c.execute("ALTER SESSION SET TIMEZONE = 'UTC'")
     created[0].state.failNextWith = { code: 407002, message: "terminated connection" }
-    await expect(c.execute("SELECT * FROM orders")).rejects.toThrow("run those statements again first")
+    await c.execute("SELECT * FROM orders")
+    expect(created[1].executed).toEqual(["USE SCHEMA analytics", "ALTER SESSION SET TIMEZONE = 'UTC'", "SELECT * FROM orders LIMIT 1001"])
+  })
+
+  test("callers waiting on the same reconnect all get the restored settings", async () => {
+    const { sdk, created } = fakeSdk()
+    const c = await connect(config, sdk)
+    await c.connect()
+    await c.execute("USE SCHEMA analytics")
+    created[0].state.up = false
+    await Promise.all([c.execute("SELECT 1"), c.execute("SELECT 2")])
+    expect(created[1].executed[0]).toBe("USE SCHEMA analytics")
+    expect(created[1].executed.slice(1).sort()).toEqual(["SELECT 1 LIMIT 1001", "SELECT 2 LIMIT 1001"])
+  })
+
+  test("a USE interrupted by a closed session is applied on the new session and remembered", async () => {
+    const { sdk, created } = fakeSdk()
+    const c = await connect(config, sdk)
+    await c.connect()
+    created[0].state.failNextWith = { code: 407002, message: "terminated connection" }
+    await c.execute("USE SCHEMA analytics")
+    expect(created[1].executed).toEqual(["USE SCHEMA analytics"])
+    created[1].state.up = false
+    await c.execute("SELECT 1")
+    expect(created[2].executed).toEqual(["USE SCHEMA analytics", "SELECT 1 LIMIT 1001"])
+  })
+
+  test("temporary objects cannot be restored: every statement started before the reconnect says so, later ones run", async () => {
+    const { sdk, created } = fakeSdk()
+    const c = await connect(config, sdk)
+    await c.connect()
+    await c.execute("CREATE TEMPORARY TABLE scratch AS SELECT 1 AS a")
+    created[0].state.up = false
+    // Both were issued against the old session, so both may depend on the temporary table.
+    const results = await Promise.allSettled([c.execute("SELECT * FROM scratch"), c.execute("SELECT count(*) FROM scratch")])
+    expect(results.map((r) => r.status)).toEqual(["rejected", "rejected"])
+    expect(String((results[0] as PromiseRejectedResult).reason)).toContain("temporary objects or open transaction")
     expect(created[1].executed).toEqual([])
+    // Issued after the loss was reported: runs on the new session.
     expect((await c.execute("SELECT 1")).rows).toEqual([[1]])
   })
 
+  test("a late error from the replaced session does not hide the loss from a later reconnect", async () => {
+    const { sdk, created } = fakeSdk()
+    const c = await connect(config, sdk)
+    await c.connect()
+    // The old session's error is delivered only after the temporary table exists on the new session.
+    let tempCreated!: () => void
+    const afterTemp = new Promise<void>((r) => (tempCreated = r))
+    created[0].state.failQueue = [{ code: 407002, message: "terminated connection", after: afterTemp }]
+    const late = c.execute("SELECT 0").catch(() => {})
+    created[0].state.up = false
+    await c.execute("SELECT 1") // reconnects; generation 1
+    await c.execute("CREATE TEMP TABLE t2 AS SELECT 1 AS a") // state on the new session
+    tempCreated()
+    await late
+    created[1].state.up = false
+    const started = c.execute("SELECT * FROM t2")
+    await expect(started).rejects.toThrow("temporary objects or open transaction")
+  })
+
+  test("a SET computed with side effects is not replayed; the session that ran it is reported as not restorable", async () => {
+    const { sdk, created } = fakeSdk()
+    const c = await connect(config, sdk)
+    await c.connect()
+    await c.execute("USE SCHEMA analytics")
+    await c.execute("SET v = (SELECT my_seq.NEXTVAL)")
+    created[0].state.up = false
+    await expect(c.execute("SELECT $v")).rejects.toThrow("temporary objects or open transaction")
+    expect(created[1].executed).toEqual(["USE SCHEMA analytics"])
+  })
+
+  test("a setting that finishes on a session already replaced is applied to the new one too", async () => {
+    const { sdk, created } = fakeSdk()
+    const c = await connect(config, sdk)
+    await c.connect()
+    let release!: () => void
+    created[0].state.holdNext = new Promise<void>((r) => (release = r))
+    const slowUse = c.execute("USE SCHEMA analytics") // still running on the first session
+    await new Promise((r) => setTimeout(r, 5)) // issued (and held) before the next failure is armed
+    created[0].state.failNextWith = { code: 407002, message: "terminated connection" }
+    await c.execute("SELECT 1") // fails, reconnects, retries on the second session
+    release()
+    await slowUse
+    expect(created[1].executed).toContain("USE SCHEMA analytics")
+    created[1].state.up = false
+    await c.execute("SELECT 2")
+    expect(created[2].executed[0]).toBe("USE SCHEMA analytics")
+  })
+
+  test("temporary state created on a session already replaced is reported to its caller, not pinned on the new one", async () => {
+    const { sdk, created } = fakeSdk()
+    const c = await connect(config, sdk)
+    await c.connect()
+    let release!: () => void
+    created[0].state.holdNext = new Promise<void>((r) => (release = r))
+    const slowTemp = c.execute("CREATE TEMP TABLE t AS SELECT 1 AS a")
+    await new Promise((r) => setTimeout(r, 5)) // issued (and held) before the next failure is armed
+    created[0].state.failNextWith = { code: 407002, message: "terminated connection" }
+    await c.execute("SELECT 1")
+    release()
+    await expect(slowTemp).rejects.toThrow("temporary objects or open transaction")
+    // The new session holds nothing unrestorable, so a later reconnect holds nothing back.
+    created[1].state.up = false
+    expect((await c.execute("SELECT 2")).rows).toEqual([[2]])
+  })
+
+  test("a committed transaction is not reported as lost; repeated settings are replayed once", async () => {
+    const { sdk, created } = fakeSdk()
+    const c = await connect(config, sdk)
+    await c.connect()
+    await c.execute("USE SCHEMA a")
+    await c.execute("USE SCHEMA b")
+    await c.execute("USE SCHEMA a")
+    await c.execute("BEGIN")
+    await c.execute("INSERT INTO t VALUES (1)")
+    await c.execute("COMMIT")
+    created[0].state.up = false
+    expect((await c.execute("SELECT 1")).rows).toEqual([[1]])
+    expect(created[1].executed).toEqual(["USE SCHEMA b", "USE SCHEMA a", "SELECT 1 LIMIT 1001"])
+  })
+
+  test("connecting again starts a fresh session: nothing recorded for the old one carries over", async () => {
+    const { sdk, created } = fakeSdk()
+    const c = await connect(config, sdk)
+    await c.connect()
+    await c.execute("CREATE TEMP TABLE t AS SELECT 1 AS a")
+    await c.execute("USE SCHEMA old")
+    await c.close()
+    await c.connect()
+    created[1].state.up = false
+    expect((await c.execute("SELECT 1")).rows).toEqual([[2]])
+    expect(created[2].executed).toEqual(["SELECT 1 LIMIT 1001"])
+  })
+
+  test("a late setting arriving while settings are replayed does not make the replay skip one", async () => {
+    const { sdk, created } = fakeSdk()
+    const c = await connect(config, sdk)
+    await c.connect()
+    await c.execute("USE SCHEMA a")
+    await c.execute("ALTER SESSION SET TIMEZONE = 'UTC'")
+    // A repeat of the first setting is still running on the old session.
+    let releaseOld!: () => void
+    created[0].state.holdNext = new Promise<void>((r) => (releaseOld = r))
+    const lateRepeat = c.execute("USE SCHEMA a")
+    await new Promise((r) => setTimeout(r, 5))
+    // The replay's first statement on the new session is held until the late repeat has completed.
+    let releaseReplay!: () => void
+    sdk.nextState = { holdNext: new Promise<void>((r) => (releaseReplay = r)) }
+    created[0].state.up = false
+    const next = c.execute("SELECT 1")
+    await new Promise((r) => setTimeout(r, 5))
+    releaseOld()
+    await new Promise((r) => setTimeout(r, 5))
+    releaseReplay()
+    await next
+    await lateRepeat
+    expect(created[1].executed).toContain("ALTER SESSION SET TIMEZONE = 'UTC'")
+  })
+
+  test("a new setting that completes on the old session during the replay is applied before the session is used", async () => {
+    const { sdk, created } = fakeSdk()
+    const c = await connect(config, sdk)
+    await c.connect()
+    await c.execute("USE SCHEMA a")
+    let releaseOld!: () => void
+    created[0].state.holdNext = new Promise<void>((r) => (releaseOld = r))
+    const lateDistinct = c.execute("ALTER SESSION SET TIMEZONE = 'UTC'") // a setting the list does not have yet
+    await new Promise((r) => setTimeout(r, 5))
+    let releaseReplay!: () => void
+    sdk.nextState = { holdNext: new Promise<void>((r) => (releaseReplay = r)) }
+    created[0].state.up = false
+    const next = c.execute("SELECT 1")
+    await new Promise((r) => setTimeout(r, 5))
+    releaseOld() // completes while the replay of "USE SCHEMA a" is held
+    await new Promise((r) => setTimeout(r, 5))
+    releaseReplay()
+    await next
+    await lateDistinct
+    const executed = created[1].executed
+    expect(executed.indexOf("ALTER SESSION SET TIMEZONE = 'UTC'")).toBeGreaterThanOrEqual(0)
+    expect(executed.indexOf("ALTER SESSION SET TIMEZONE = 'UTC'")).toBeLessThan(executed.indexOf("SELECT 1 LIMIT 1001"))
+  })
+
+  test("a reconnect whose settings never settle is refused, not installed half-applied", async () => {
+    const { sdk, created } = fakeSdk()
+    const c = await connect(config, sdk)
+    await c.connect()
+    await c.execute("USE SCHEMA a") // something to replay
+    // Forty distinct settings are still running on the old session, each held until released.
+    const releases: Array<() => void> = []
+    created[0].state.holdQueue = Array.from({ length: 40 }, () => new Promise<void>((r) => releases.push(r)))
+    const pending = Array.from({ length: 40 }, (_, i) => c.execute(`SET v${i} = ${i}`).catch(() => {}))
+    await new Promise((r) => setTimeout(r, 5))
+    // Each replay statement on the new session lets one of them finish first (the new session answers slower), so
+    // the list grows during every pass and never ends a pass unchanged.
+    sdk.nextState = { onExecute: () => releases.shift()?.(), delayMs: 15 }
+    created[0].state.up = false
+    await expect(c.execute("SELECT 1")).rejects.toThrow("session settings kept changing")
+    expect(created[1].destroyed).toBe(true)
+    for (const r of releases.splice(0)) r()
+    await Promise.all(pending)
+  })
+
+  test("a setting still running when the caller connects afresh is not carried onto the new session", async () => {
+    const { sdk, created } = fakeSdk()
+    const c = await connect(config, sdk)
+    await c.connect()
+    let release!: () => void
+    created[0].state.holdNext = new Promise<void>((r) => (release = r))
+    const slowUse = c.execute("USE SCHEMA old")
+    await new Promise((r) => setTimeout(r, 5))
+    await c.close()
+    await c.connect()
+    release()
+    await slowUse.catch(() => {})
+    expect(created[1].executed).toEqual([])
+    created[1].state.up = false
+    await c.execute("SELECT 1")
+    expect(created[2].executed).toEqual(["SELECT 1 LIMIT 1001"])
+  })
+
   test("an expired session token (390114) is also retried", async () => {
     const { sdk, created } = fakeSdk()
     const c = await connect(config, sdk)
@@ -194,6 +444,7 @@ describe("isRetrySafe", () => {
       "DESCRIBE TABLE t",
       "SELECT 'insert into x' AS label",
       "SELECT 1;",
+      "SELECT CURRENT_DATE()",
     ])
       expect(isRetrySafe(ok)).toBe(true)
     for (const no of [
@@ -205,11 +456,23 @@ describe("isRetrySafe", () => {
       "CALL refresh()",
       "COPY INTO t FROM @s",
       "USE SCHEMA x",
+      "SELECT my_seq.NEXTVAL",
+      "select seq1.nextval, 2",
+      "SELECT GETNEXTVAL(my_seq)",
+      "SELECT SYSTEM$CANCEL_ALL_QUERIES(1)",
       "",
     ])
       expect(isRetrySafe(no)).toBe(false)
   })
 
+  test("only effect-free single settings are replayable; the rest is session state", () => {
+    for (const ok of ["USE SCHEMA x", "SET v = 'a;b'", "ALTER SESSION SET TIMEZONE = 'UTC'"]) expect(isSessionSetting(ok)).toBe(true)
+    for (const no of ["SET v = (SELECT my_seq.NEXTVAL)", "SET a = 1; SET b = 2", "SET v = SYSTEM$WAIT(1)"]) {
+      expect(isSessionSetting(no)).toBe(false)
+      expect(holdsSessionState(no)).toBe(true)
+    }
+  })
+
   test("session-changing statements are recognised", () => {
     for (const yes of ["USE SCHEMA x", "use warehouse w", "ALTER SESSION SET TIMEZONE = 'UTC'", "SET v = 1", "CREATE TEMP TABLE t (a int)", "create or replace temporary table t as select 1", "BEGIN"])
       expect(changesSession(yes)).toBe(true)
diff --git a/packages/opencode/src/altimate/debug/collect.ts b/packages/opencode/src/altimate/debug/collect.ts
index d641972ded..2d35a56241 100644
--- a/packages/opencode/src/altimate/debug/collect.ts
+++ b/packages/opencode/src/altimate/debug/collect.ts
@@ -10,6 +10,7 @@ import os from "os"
 import path from "path"
 import dns from "dns/promises"
 import { parse as parseJsonc } from "jsonc-parser"
+import { env as flagEnv, truthy as flagTruthy } from "@opencode-ai/core/flag/flag"
 import { Global } from "@opencode-ai/core/global"
 import { InstallationVersion } from "@opencode-ai/core/installation/version"
 import { resolveInstall } from "@/installation"
@@ -116,7 +117,8 @@ async function connectionFacts(): Promise<ConnectionFact[]> {
   const out: ConnectionFact[] = []
   let names: string[] = []
   try {
-    names = Registry.list().warehouses.map((w) => w.name)
+    // Names only: `Registry.list()` also queues a warehouse census for telemetry, which this command must not send.
+    names = Registry.names()
   } catch {
     return out
   }
@@ -152,56 +154,142 @@ export function connectionFact(name: string, config: Record<string, unknown>, re
       .map((k) => (SENSITIVE_FIELD.test(k) ? `${k} (secret${present(config, k) ? "" : ", in credential store"})` : k))
       .sort(),
   }
-  if (needsPassword(fact)) fact.passwordAvailable = resolved !== undefined && CREDENTIAL_FIELDS.some((k) => present(resolved, k))
+  if (needsPassword(fact)) fact.passwordAvailable = resolved !== undefined && credentialFieldsFor(fact.type).some((k) => present(resolved, k))
   return fact
 }
 
-/** Fields that can each sign a connection in on their own: a secret, a key or key file, a token, a full connection
- * string, or a service-account file. */
-const CREDENTIAL_FIELDS = [
-  "password",
-  "private_key",
-  "privateKey",
-  "private_key_path",
-  "privateKeyPath",
-  "token",
-  "access_token",
-  "connection_string",
-  "credentials_json",
-  "keyfile_json",
-  "credentials_path",
-  "keyfile",
-]
+/** Fields that sign a connection in on their own, for the driver of each warehouse type: a field the driver does
+ * not read (a Postgres config with `credentials_path`) does not make that connection usable. */
+const COMMON_CREDENTIALS = ["password", "connection_string"]
+const CREDENTIALS_BY_TYPE: Record<string, string[]> = {
+  snowflake: ["private_key", "privateKey", "private_key_path", "privateKeyPath", "token", "access_token"],
+  databricks: ["token", "access_token"],
+  bigquery: ["credentials_json", "keyfile_json", "credentials_path", "keyfile"],
+}
+
+export function credentialFieldsFor(type: string): string[] {
+  return [...COMMON_CREDENTIALS, ...(CREDENTIALS_BY_TYPE[type] ?? [])]
+}
+
+/** Where config can come from, in the config loader's merge order (later wins). Replaceable in tests. */
+export interface ConfigSources {
+  global: string
+  /** The folder the bundle runs in. */
+  cwd: string
+  home: string
+  /** `ALTIMATE_CLI_CONFIG` / `OPENCODE_CONFIG`: one extra file. */
+  file?: string
+  /** `ALTIMATE_CLI_CONFIG_DIR` / `OPENCODE_CONFIG_DIR`: one extra folder. */
+  dir?: string
+  /** `OPENCODE_DISABLE_PROJECT_CONFIG`: the project's own files are not read. */
+  noProject?: boolean
+  /** `ALTIMATE_CLI_CONFIG_CONTENT` / `OPENCODE_CONFIG_CONTENT`: inline JSON. */
+  content?: string
+}
+
+function defaultSources(): ConfigSources {
+  return {
+    global: Global.Path.config,
+    cwd: process.cwd(),
+    home: Global.Path.home,
+    // Read as the loader reads them: the documented ALTIMATE_CLI_* name first, then the OPENCODE_* fallback.
+    file: flagEnv("OPENCODE_CONFIG") || undefined,
+    dir: flagEnv("OPENCODE_CONFIG_DIR") || undefined,
+    content: flagEnv("OPENCODE_CONFIG_CONTENT") || undefined,
+    noProject: flagTruthy("OPENCODE_DISABLE_PROJECT_CONFIG"),
+  }
+}
+
+/** The git root above `start` (the loader's project boundary). Outside a repository the project's worktree is the
+ * filesystem root, so every ancestor counts. */
+function projectRoot(start: string): string {
+  for (let dir = path.resolve(start); ; dir = path.dirname(dir)) {
+    if (fs.existsSync(path.join(dir, ".git"))) return dir
+    if (path.dirname(dir) === dir) return dir
+  }
+}
+
+/** Folders from `from` up to `to`, nearest first. */
+function upwards(from: string, to: string): string[] {
+  const out: string[] = []
+  for (let dir = path.resolve(from); ; dir = path.dirname(dir)) {
+    out.push(dir)
+    if (dir === path.resolve(to) || path.dirname(dir) === dir) return out
+  }
+}
 
-const CONFIG_NAMES = ["config.json", "opencode.json", "opencode.jsonc", "altimate-code.json", "altimate-code.jsonc"]
+/** Config files in the order `config/config.ts` merges them (see `ConfigPaths.directories` and `files`). */
+export function configFiles(src: ConfigSources): string[] {
+  const root = projectRoot(src.cwd)
+  const inDir = (dir: string) => ["altimate-code.json", "altimate-code.jsonc", "opencode.json", "opencode.jsonc"].map((n) => path.join(dir, n))
+  const configDirs = [
+    ...(src.noProject ? [] : upwards(src.cwd, root).flatMap((d) => [path.join(d, ".altimate-code"), path.join(d, ".opencode")])),
+    path.join(src.home, ".altimate-code"),
+    path.join(src.home, ".opencode"),
+    ...(src.dir ? [src.dir] : []),
+  ]
+  return [
+    ...["config.json", "opencode.json", "opencode.jsonc", "altimate-code.json", "altimate-code.jsonc"].map((n) => path.join(src.global, n)),
+    ...(src.file ? [src.file] : []),
+    // Project files from the root down, so the folder the bundle runs in wins; in one folder `.jsonc` wins.
+    ...(src.noProject
+      ? []
+      : upwards(src.cwd, root)
+          .reverse()
+          .flatMap((d) => [path.join(d, "opencode.json"), path.join(d, "opencode.jsonc")])),
+    ...[...new Set(configDirs)].flatMap(inDir),
+  ]
+}
+
+type McpEntry = { type?: string; enabled?: boolean }
+type RawMcpEntry = McpEntry & { command?: unknown; args?: unknown; url?: unknown }
+
+/** A config's MCP servers as `normalizeMcpConfig` in config/config.ts leaves them: `mcpServers` only when there is no
+ * `mcp`, entries that are not objects dropped, and the type inferred from `command`/`args` (local) or `url` (remote). */
+function mcpOf(cfg: unknown): Record<string, McpEntry> {
+  if (!cfg || typeof cfg !== "object") return {}
+  const c = cfg as { mcp?: unknown; mcpServers?: unknown }
+  const raw = ("mcp" in c ? c.mcp : c.mcpServers) as Record<string, RawMcpEntry> | undefined
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {}
+  const out: Record<string, McpEntry> = {}
+  for (const [name, e] of Object.entries(raw)) {
+    if (!e || typeof e !== "object") continue
+    const type = e.command || e.args ? "local" : typeof e.url === "string" && e.url ? "remote" : e.type
+    out[name] = { ...(type ? { type } : {}), ...(typeof e.enabled === "boolean" ? { enabled: e.enabled } : {}) }
+  }
+  return out
+}
 
 /**
- * MCP servers, read straight from the config files: global, then the project folder and its `.opencode` /
- * `.altimate-code` folders, later files overriding earlier ones. The full config loader needs a project instance,
- * which the bundle deliberately does not start (it runs plugins and can hang the way the bundle is meant to
- * diagnose). undefined when no file could be read.
+ * MCP servers, read straight from the config sources in the loader's merge order, each server's fields merged as
+ * the loader merges them. The full loader needs a project instance, which the bundle deliberately does not start
+ * (it runs plugins and can hang the way the bundle is meant to diagnose). undefined when nothing could be read.
  */
-export function mcpFacts(dirs: { global: string; project: string } = { global: Global.Path.config, project: process.cwd() }): Facts["mcpServers"] {
-  const files = [
-    ...CONFIG_NAMES.map((n) => path.join(dirs.global, n)),
-    ...CONFIG_NAMES.filter((n) => n !== "config.json").map((n) => path.join(dirs.project, n)),
-    ...[".opencode", ".altimate-code"].flatMap((d) => CONFIG_NAMES.filter((n) => n !== "config.json").map((n) => path.join(dirs.project, d, n))),
-  ]
-  const servers = new Map<string, { type: string; enabled: boolean }>()
+export function mcpFacts(src: ConfigSources = defaultSources()): Facts["mcpServers"] {
+  const servers = new Map<string, McpEntry>()
   let read = false
-  for (const file of files) {
+  const apply = (cfg: unknown) => {
+    read = true
+    for (const [name, v] of Object.entries(mcpOf(cfg))) servers.set(name, { ...servers.get(name), ...v })
+  }
+  for (const file of configFiles(src)) {
     let text: string
     try {
       text = fs.readFileSync(file, "utf-8")
     } catch {
       continue
     }
-    const cfg = parseJsonc(text) as { mcp?: Record<string, { type?: string; enabled?: boolean }> } | undefined
-    if (!cfg || typeof cfg !== "object") continue
-    read = true
-    for (const [name, v] of Object.entries(cfg.mcp ?? {})) servers.set(name, { type: v?.type ?? "?", enabled: v?.enabled !== false })
+    const cfg = parseJsonc(text)
+    if (cfg && typeof cfg === "object") apply(cfg)
+  }
+  if (src.content) {
+    const cfg = parseJsonc(src.content)
+    if (cfg && typeof cfg === "object") apply(cfg)
   }
-  return read ? [...servers.entries()].map(([name, v]) => ({ name, ...v })).sort((a, b) => a.name.localeCompare(b.name)) : undefined
+  if (!read) return undefined
+  return [...servers.entries()]
+    .map(([name, v]) => ({ name, type: v.type ?? "?", enabled: v.enabled !== false }))
+    .sort((a, b) => a.name.localeCompare(b.name))
 }
 
 export interface ProbeDeps {
@@ -253,7 +341,8 @@ function telemetryHost(): string {
   const cs = process.env["APPLICATIONINSIGHTS_CONNECTION_STRING"]
   const endpoint = cs?.split(";").find((p) => p.trim().startsWith("IngestionEndpoint="))?.split("=")[1]
   try {
-    if (endpoint) return new URL(endpoint).host
+    // The hostname alone: a port in the endpoint is not part of the name DNS resolves.
+    if (endpoint) return new URL(endpoint).hostname
   } catch {
     // fall through to the built-in endpoint
   }
@@ -270,11 +359,14 @@ function networkTargets(connections: ConnectionFact[], account: Facts["account"]
     if (c.type === "snowflake") {
       const acct = config?.account
       if (typeof acct === "string" && acct && !acct.includes("/")) {
-        out.push({ target: `Snowflake (${c.name})`, host: acct.includes(".") && acct.endsWith("snowflakecomputing.com") ? acct : `${acct}.snowflakecomputing.com` })
+        // Only a real Snowflake domain is probed as given; anything else is treated as an account locator.
+        const host = acct.toLowerCase().endsWith(".snowflakecomputing.com") ? acct : `${acct}.snowflakecomputing.com`
+        if (/^[A-Za-z0-9.-]+$/.test(host)) out.push({ target: `Snowflake (${c.name})`, host })
       }
     }
     if (c.type === "databricks") {
-      const h = config?.server_hostname ?? config?.host
+      // The same aliases the driver accepts (normalizeConfig maps serverHostname to server_hostname).
+      const h = config?.server_hostname ?? config?.serverHostname ?? config?.host
       if (typeof h === "string" && h && !h.includes("/")) out.push({ target: `Databricks (${c.name})`, host: h })
     }
   }
diff --git a/packages/opencode/src/altimate/debug/mode.ts b/packages/opencode/src/altimate/debug/mode.ts
index 0ea11c5621..b46b050301 100644
--- a/packages/opencode/src/altimate/debug/mode.ts
+++ b/packages/opencode/src/altimate/debug/mode.ts
@@ -9,6 +9,7 @@
  */
 import os from "os"
 import { fileLog } from "@/altimate/util/file-log"
+import { redact } from "./report"
 
 export const HEARTBEAT_MS = 15_000
 
@@ -38,8 +39,8 @@ interface Running {
 
 const running = new Map<string, Running>()
 let heartbeat: ReturnType<typeof setInterval> | undefined
-/** For calls without an id: a counter, so two parallel calls of one tool never share a key. */
-let fallbackSeq = 0
+/** Makes each traced call unique, so two parallel calls never share a key. */
+let traceSeq = 0
 
 function ensureHeartbeat(): void {
   if (heartbeat) return
@@ -56,7 +57,8 @@ function ensureHeartbeat(): void {
 /** Records a tool call starting. Returns the matching end; a no-op pair when debug mode is off. */
 export function traceToolCall(tool: string, callID: string | undefined): (status: "success" | "error", detail?: string) => void {
   if (!isDebugMode()) return () => {}
-  const call = callID ?? `${tool}-${++fallbackSeq}`
+  // Keyed per occurrence: a provider can repeat a call id, and a repeat must not overwrite or end the other call.
+  const call = `${callID ?? tool}#${++traceSeq}`
   const startedAt = Date.now()
   running.set(call, { tool, startedAt })
   ensureHeartbeat()
@@ -72,11 +74,28 @@ export function traceToolCall(tool: string, callID: string | undefined): (status
       call,
       status,
       duration_ms: Date.now() - startedAt,
-      ...(detail ? { detail: detail.slice(0, 300) } : {}),
+      // Tool errors can quote credentials, connection strings or paths: redacted before they are written.
+      ...(detail ? { detail: redact(detail, logRedaction()).slice(0, 300) } : {}),
     })
   }
 }
 
+/** Each value gathered on its own, so one failing lookup does not drop the others. */
+function logRedaction(): { home?: string; username?: string; hostname?: string } {
+  const attempt = <T>(fn: () => T): T | undefined => {
+    try {
+      return fn()
+    } catch {
+      return undefined
+    }
+  }
+  return {
+    home: attempt(() => os.homedir()),
+    username: attempt(() => os.userInfo().username) ?? process.env["USER"] ?? process.env["USERNAME"],
+    hostname: attempt(() => os.hostname()),
+  }
+}
+
 export function resetForTests(): void {
   running.clear()
   if (heartbeat) clearInterval(heartbeat)
diff --git a/packages/opencode/src/altimate/debug/report.ts b/packages/opencode/src/altimate/debug/report.ts
index 7db485097f..6e13cb7b25 100644
--- a/packages/opencode/src/altimate/debug/report.ts
+++ b/packages/opencode/src/altimate/debug/report.ts
@@ -121,6 +121,11 @@ export interface LogFindings {
    */
   endedMidTool: Array<{ run: string; at: string; tools: string; pid?: number; alive?: boolean }>
   debugTracing: boolean
+  /** Project loads in log lines with no run id (older logs): they cannot be tied to a process, so they are shown on
+   * their own rather than counted as app starts. */
+  unattributedLoads: number
+  /** A start line said debug mode was on, whether or not any tool call followed. */
+  debugOn: boolean
 }
 
 export function analyzeLog(lines: LogLine[]): LogFindings {
@@ -133,17 +138,27 @@ export function analyzeLog(lines: LogLine[]): LogFindings {
   const inFlight = new Map<string, Map<string, string>>() // run -> callID -> tool
   const lastAtByRun = new Map<string, string>()
   const pidByRun = new Map<string, number>()
-  let starts = 0
   let snapshotFailures = 0
   let debugTracing = false
+  let debugOn = false
+  let unattributedLoads = 0
+  /** Each run's first timestamp, and what kind of start it shows: a start line (main or worker thread), or only
+   * project loads (logs written before start lines existed). A process counts once however many projects it loads. */
+  const runFirstAt = new Map<string, string>()
+  const runStart = new Map<string, "main" | "worker" | "loads-only">()
 
   for (const l of lines) {
     if (l.run) lastAtByRun.set(l.run, l.timestamp)
-    if (l.message === "altimate-code started" && l.run && Number(l.fields.pid) > 0) pidByRun.set(l.run, Number(l.fields.pid))
+    if (l.run && !runFirstAt.has(l.run)) runFirstAt.set(l.run, l.timestamp)
+    if (l.message === "altimate-code started") {
+      if (l.run && Number(l.fields.pid) > 0) pidByRun.set(l.run, Number(l.fields.pid))
+      if (l.fields.debug === "true") debugOn = true
+      if (l.run) runStart.set(l.run, l.fields.thread === "worker" ? "worker" : "main")
+    }
     if (l.message === "creating instance") {
-      starts++
-      const day = l.timestamp.slice(0, 10)
-      startsByDay.set(day, (startsByDay.get(day) ?? 0) + 1)
+      // A load with no run id cannot be tied to a process (one process may load several projects).
+      if (!l.run) unattributedLoads++
+      else if (!runStart.has(l.run)) runStart.set(l.run, "loads-only")
     }
     if (l.level === "WARN" || l.level === "ERROR") {
       const t = messageTemplate(l)
@@ -183,6 +198,12 @@ export function analyzeLog(lines: LogLine[]): LogFindings {
     if (l.message === "tool end" && l.fields.call) inFlight.get(l.run)?.delete(l.fields.call)
   }
 
+  for (const [run, kind] of runStart) {
+    if (kind === "worker") continue // the TUI's worker belongs to a process already counted by its main thread
+    const day = (runFirstAt.get(run) ?? "").slice(0, 10)
+    if (day) startsByDay.set(day, (startsByDay.get(day) ?? 0) + 1)
+  }
+
   const endedMidTool: LogFindings["endedMidTool"] = []
   for (const [run, calls] of inFlight) {
     if (calls.size === 0) continue
@@ -193,7 +214,7 @@ export function analyzeLog(lines: LogLine[]): LogFindings {
     lines: lines.length,
     firstAt: lines[0]?.timestamp,
     lastAt: lines[lines.length - 1]?.timestamp,
-    starts,
+    starts: [...startsByDay.values()].reduce((a, b) => a + b, 0),
     startsByDay: [...startsByDay.entries()].sort().map(([day, n]) => ({ day, starts: n })),
     problems: [...problems.values()].sort((a, b) => b.count - a.count),
     mcpFailures: [...mcp.entries()].map(([server, v]) => ({ server, ...v })).sort((a, b) => b.count - a.count),
@@ -203,6 +224,8 @@ export function analyzeLog(lines: LogLine[]): LogFindings {
     snapshotFailures,
     endedMidTool,
     debugTracing,
+    debugOn,
+    unattributedLoads,
   }
 }
 
@@ -370,7 +393,13 @@ export function detectProblems(f: Facts): Finding[] {
     })
   }
 
-  if (!log?.debugTracing) {
+  if (log && !log.debugTracing && log.debugOn) {
+    out.push({
+      severity: "info",
+      title: "Debug mode was on, but no tool calls were traced",
+      detail: "Debug mode was on, but the agent made no tool calls in this log, so there is nothing to trace yet. Reproduce the problem with debug mode on, then run this command again.",
+    })
+  } else if (!log?.debugTracing) {
     out.push({
       severity: "info",
       title: "Debug mode was not on",
@@ -418,7 +447,7 @@ export function renderReport(f: Facts, findings: Finding[]): string {
         ["Install method", f.installMethod ?? "unknown"],
         ["OS", `${f.os} (${f.arch})`],
         ["Runtime", f.runtime],
-        ["Debug traces in the log", f.log?.debugTracing ? "yes" : "no (debug mode was off)"],
+        ["Debug traces in the log", f.log?.debugTracing ? "yes" : f.log?.debugOn ? "no (debug mode on, no tool calls)" : "no (debug mode was off)"],
         [
           "Telemetry",
           f.telemetry.checked === false
@@ -461,13 +490,15 @@ export function renderReport(f: Facts, findings: Finding[]): string {
   if (!log) parts.push(`No log file found${f.logPath ? ` at ${f.logPath}` : ""}.\n`)
   else {
     parts.push(
-      `${log.lines} lines from ${log.firstAt ?? "?"} to ${log.lastAt ?? "?"}; ${log.starts} app starts. Browser sign-ins: ${log.signIns.waiting} requested, ${log.signIns.completed} completed, ${log.signIns.failed} failed.\n`,
+      `${log.lines} lines from ${log.firstAt ?? "?"} to ${log.lastAt ?? "?"}; ${log.starts} app starts` +
+        (log.unattributedLoads ? ` (plus ${log.unattributedLoads} project loads in older lines that cannot be tied to a process)` : "") +
+        `. Browser sign-ins: ${log.signIns.waiting} requested, ${log.signIns.completed} completed, ${log.signIns.failed} failed.\n`,
     )
     parts.push(`### Runs that ended while a tool was running\n`)
     parts.push(
       table(
         ["Run", "Last activity", "Tools not finished", "Process"],
-        log.endedMidTool.map((e) => [e.run, e.at, e.tools, e.alive === undefined ? "unknown" : e.alive ? "still running" : "ended"]),
+        log.endedMidTool.map((e) => [e.run, e.at, e.tools, e.alive === undefined ? "unknown" : e.alive ? "still running (or its pid was reused)" : "ended"]),
       ),
     )
     parts.push(`### Warehouse connection failures\n`)
diff --git a/packages/opencode/src/altimate/native/connections/credential-store.ts b/packages/opencode/src/altimate/native/connections/credential-store.ts
index d3879f517c..c70466cc23 100644
--- a/packages/opencode/src/altimate/native/connections/credential-store.ts
+++ b/packages/opencode/src/altimate/native/connections/credential-store.ts
@@ -136,7 +136,10 @@ export async function getCredential(
   if (!store) return null
   try {
     return await store.get(`${connectionName}/${field}`)
-  } catch {
+  } catch (e) {
+    // Treated as absent so a locked store cannot stop every connect, but logged, so a connection that then fails
+    // for want of its password shows why.
+    Log.Default.warn(`could not read '${field}' for connection '${connectionName}' from ${store.name}`, { error: String(e) })
     return null
   }
 }
@@ -156,17 +159,53 @@ export async function deleteCredential(
 }
 
 /**
- * Delete every secret stored for connection `name`, except the fields `keep` holds. Entries are keyed by
- * connection name only, so without this a removed connection's secrets stay in the OS store, and a connection
- * re-added under the same name gets them back at the next restart (`resolveConfig` fills absent fields from the
- * store): an old private key would then outrank the new sign-in method.
+ * Delete every secret stored for connection `name`, except the fields `keep` holds, and return the fields that are
+ * still stored because the store refused to delete them. Without this a removed connection's secrets stay in the
+ * OS store, and a connection re-added under the same name gets them back at the next restart (`resolveConfig`
+ * fills absent fields from the store): an old private key would then outrank the new sign-in method.
+ *
+ * Entries are keyed by connection name only. Only `saveConnection` writes them, for the saved (global) connection
+ * of that name; a project's own connections file never stores a secret here. A project file that defines a
+ * connection of the same name without its secret was reading the saved connection's secret, and loses it when that
+ * saved connection is removed or re-saved without it.
  */
-export async function forgetCredentials(name: string, keep?: ConnectionConfig): Promise<void> {
+export async function forgetCredentials(name: string, keep?: ConnectionConfig): Promise<string[]> {
+  const store = await getBackend()
+  if (!store) return []
+  const notRemoved: string[] = []
   for (const field of SENSITIVE_FIELDS) {
     const kept = keep?.[field]
     if (typeof kept === "string" && kept) continue
-    await deleteCredential(name, field)
+    const account = `${name}/${field}`
+    // Read directly, not through `getCredential`, which reports a failed read as "absent": a secret the store could
+    // not read may still be there, so its delete is attempted and a failure is reported.
+    let present: boolean | "unknown"
+    try {
+      present = (await store.get(account)) !== null
+    } catch {
+      present = "unknown"
+    }
+    if (present === false) continue
+    let deleted: boolean
+    try {
+      deleted = await store.delete(account)
+    } catch {
+      deleted = false
+    }
+    // A delete that reports "nothing to delete" after an unreadable entry cannot be told from a refusal.
+    if (!deleted) notRemoved.push(field)
   }
+  return notRemoved
+}
+
+/** The warning for secrets the store would not delete, naming where to remove them by hand. */
+export function notRemovedWarning(name: string, fields: string[]): string {
+  // "May": a store that could not be read cannot confirm whether an entry was there to remove.
+  return (
+    `Could not confirm that ${fields.map((f) => `'${f}'`).join(", ")} for connection '${name}' ${fields.length === 1 ? "was" : "were"} removed ` +
+    `from the system credential store; if ${fields.length === 1 ? "it remains, it" : "they remain, they"} would be used again after a restart. ` +
+    `Check with your keychain tool: service "altimate-code", account "${name}/<field>".`
+  )
 }
 
 /**
@@ -210,15 +249,18 @@ export async function saveConnection(
       const warning =
         `Could not store '${field}' for connection '${name}' securely, so it was not saved: ` +
         `the connection works in this session but will fail after a restart. ` +
-        `Set ALTIMATE_CODE_CONN_${name.toUpperCase()} to the connection's full config as JSON instead.`
+        `Set the environment variable ALTIMATE_CODE_CONN_${name.toUpperCase()} to the connection's full config as JSON instead` +
+        (/[^A-Za-z0-9_]/.test(name)
+          ? ` (the name contains characters a shell assignment cannot use, so set it with \`env 'ALTIMATE_CODE_CONN_${name.toUpperCase()}=…'\`).`
+          : ".")
       Log.Default.warn(warning)
       warnings.push(warning)
       delete sanitized[field]
     }
   }
-  // Secrets a previous config under this name stored, which this one no longer has. Only once every new secret
-  // was stored: a failed write must not also discard the credentials that still work.
-  if (warnings.length === 0) await forgetCredentials(name, config)
+  // Secrets an earlier config under this name stored, which this one no longer has, are removed by the caller with
+  // `forgetCredentials` once the new config is safely on disk: removed now, a failed config write would leave the
+  // old config naming secrets that are gone.
   return { sanitized, warnings }
 }
 
diff --git a/packages/opencode/src/altimate/native/connections/registry.ts b/packages/opencode/src/altimate/native/connections/registry.ts
index 72b631fb7e..aa2c2f9128 100644
--- a/packages/opencode/src/altimate/native/connections/registry.ts
+++ b/packages/opencode/src/altimate/native/connections/registry.ts
@@ -22,7 +22,10 @@ import { Instance } from "@/project/instance"
 import { Log } from "@/altimate/util/log"
 import type { ConnectionConfig, Connector } from "@altimateai/drivers"
 import { isLocalFilePath, normalizeConfig } from "@altimateai/drivers"
-import { forgetCredentials, resolveConfig, saveConnection } from "./credential-store"
+import { forgetCredentials, notRemovedWarning, resolveConfig, saveConnection } from "./credential-store"
+// altimate_change start — the shared home, which honours the test-isolation override
+import { Global } from "@/global"
+// altimate_change end
 import { startTunnel, extractSshConfig, closeTunnel } from "./ssh-tunnel"
 import type { WarehouseInfo } from "../types"
 import { Telemetry } from "../../../telemetry"
@@ -46,7 +49,10 @@ let loaded = false
 // ---------------------------------------------------------------------------
 
 function globalConfigPath(): string {
-  return path.join(os.homedir(), ".altimate-code", "connections.json")
+  // altimate_change start — the same home Global.Path uses, so the test preload's OPENCODE_TEST_HOME keeps the
+  // suite out of the developer's real connections (Bun caches os.homedir(), so changing HOME does not).
+  return path.join(Global.Path.home, ".altimate-code", "connections.json")
+  // altimate_change end
 }
 
 // altimate_change start — the project root, not the process working directory
@@ -471,12 +477,30 @@ export function isRecoverableFailure(category: string): boolean {
 // Public API
 // ---------------------------------------------------------------------------
 
+// altimate_change start — the account a sign-in notice is reported under (see SignInNotice.rememberOrigin)
+function accountOf(config: ConnectionConfig | undefined): string {
+  return typeof config?.account === "string" ? config.account : ""
+}
+// altimate_change end
+
+// altimate_change start — connection names without the census `list()` sends (used by `debug bundle`)
+export function names(): string[] {
+  ensureLoaded()
+  return [...configs.keys()]
+}
+// altimate_change end
+
 /** Get a connector instance (creates lazily). */
 export async function get(name: string): Promise<Connector> {
   ensureLoaded()
 
   const cached = connectors.get(name)
-  if (cached) return cached
+  if (cached) {
+    // altimate_change start — a reused connection can reconnect and ask for a browser sign-in; route it here
+    SignInNotice.rememberOrigin(accountOf(configs.get(name)))
+    // altimate_change end
+    return cached
+  }
 
   // If a connector is already being created, await the same Promise
   const inflight = pending.get(name)
@@ -493,14 +517,14 @@ export async function get(name: string): Promise<Connector> {
   // connecting: an attempt that hangs or takes the process down never reaches
   // the outcome event below, so without this it leaves no trace at all.
   SignInNotice.install()
-  SignInNotice.rememberOrigin()
+  SignInNotice.rememberOrigin(accountOf(config))
   fileLog("INFO", "warehouse-connect", "connecting", { name, type: config.type, auth: authMethod })
   try {
     Telemetry.track({
       type: "warehouse_connect_started",
       timestamp: startTime,
       session_id: Telemetry.getContext().sessionId,
-      warehouse_type: config.type,
+      warehouse_type: config.type ?? "unknown",
       auth_method: authMethod,
     })
   } catch {}
@@ -676,6 +700,12 @@ export async function add(
     existing[name] = sanitized
     fs.writeFileSync(globalPath, JSON.stringify(existing, null, 2), "utf-8")
 
+    // altimate_change start — only now that the new config is on disk: drop secrets an earlier config under this
+    // name stored and this one no longer uses (an old private key would outrank a new sign-in method).
+    const notRemoved = await forgetCredentials(name, normalized)
+    if (notRemoved.length > 0) warnings.push(notRemovedWarning(name, notRemoved))
+    // altimate_change end
+
     // In-memory: keep normalized config (with credentials) so the current
     // session can connect even when keytar is unavailable. Only the disk
     // file uses the sanitized version (credentials stripped).
@@ -707,7 +737,7 @@ export async function add(
 }
 
 /** Remove a connection from global config. */
-export async function remove(name: string): Promise<{ success: boolean; error?: string }> {
+export async function remove(name: string): Promise<{ success: boolean; error?: string; warnings?: string[] }> {
   try {
     ensureLoaded()
 
@@ -736,8 +766,10 @@ export async function remove(name: string): Promise<{ success: boolean; error?:
 
     // altimate_change start — remove its secrets from the OS credential store too. Entries are keyed by name
     // only, so they are kept while this project's config or an env var still defines a connection by that name.
-    const stillDefined = name in loadFromFile(localConfigPath()) || name in loadFromEnv()
-    if (!stillDefined) await forgetCredentials(name)
+    // (Own properties only: a connection named "constructor" must not count as defined.)
+    const stillDefined = Object.hasOwn(loadFromFile(localConfigPath()), name) || Object.hasOwn(loadFromEnv(), name)
+    const notRemoved = stillDefined ? [] : await forgetCredentials(name)
+    if (notRemoved.length > 0) return { success: true, warnings: [notRemovedWarning(name, notRemoved)] }
     // altimate_change end
 
     return { success: true }
diff --git a/packages/opencode/src/altimate/native/connections/sign-in-notice.ts b/packages/opencode/src/altimate/native/connections/sign-in-notice.ts
index ccf416fc5c..9751092a6b 100644
--- a/packages/opencode/src/altimate/native/connections/sign-in-notice.ts
+++ b/packages/opencode/src/altimate/native/connections/sign-in-notice.ts
@@ -50,7 +50,9 @@ export function toastFor(n: BrowserSignInNotice): SignInToast | undefined {
   if (n.phase === "completed") {
     return { title: "Signed in", message: `Signed in to ${label(n)}.`, variant: "success", duration: COMPLETED_TOAST_MS }
   }
-  return undefined
+  // Replaces the "Waiting for sign-in" toast, which would otherwise stay up for its full two minutes.
+  // The driver reports "failed" for any connect error after the sign-in page opened, not only an abandoned sign-in.
+  return { title: "Connection failed", message: `Signing in or connecting to ${label(n)} did not complete.`, variant: "error", duration: COMPLETED_TOAST_MS }
 }
 
 /** The instance and workspace a connect was started from. */
@@ -59,12 +61,15 @@ export interface SignInOrigin {
   workspace?: string
 }
 
-/** Where the latest connect started. The SDK calls back on its own, outside any instance, and a toast published
- * without a workspace is dropped by a TUI that is showing one; so the origin is captured when the connect starts. */
-let origin: SignInOrigin = {}
+/** Where each warehouse account was last used from. The SDK calls back on its own, outside any instance, and a
+ * toast published without a workspace is dropped by a TUI that is showing one; so the origin is captured when the
+ * connection is asked for, per account, so overlapping sign-ins to different accounts each reach their own
+ * workspace. */
+const origins = new Map<string, SignInOrigin>()
 
-/** Call when a connect starts, from the caller's own context. */
-export function rememberOrigin(): void {
+/** Call whenever a connection is handed out (new or reused: a reused one can reconnect and ask for a sign-in), from
+ * the caller's own context. */
+export function rememberOrigin(account: string): void {
   const fiber = Fiber.getCurrent()
   let instance: InstanceContext | undefined
   if (fiber) instance = Context.getReferenceUnsafe(fiber.context, InstanceRef)
@@ -76,7 +81,7 @@ export function rememberOrigin(): void {
     }
   }
   const workspace = WorkspaceContext.workspaceID ?? (fiber ? Context.getReferenceUnsafe(fiber.context, WorkspaceRef) : undefined)
-  origin = { instance, workspace }
+  origins.set(account, { instance, workspace })
 }
 
 export interface SignInNoticeDeps {
@@ -116,7 +121,7 @@ export function handle(n: BrowserSignInNotice, deps: SignInNoticeDeps = defaultD
     if (n.phase === "waiting") deps.printLine(`${t.title}: ${t.message}`)
     return
   }
-  deps.toast(t, origin).catch((err) => fileLog("WARN", "warehouse-sign-in", "could not show the sign-in notice", { err: String(err) }))
+  deps.toast(t, origins.get(n.account ?? "") ?? {}).catch((err) => fileLog("WARN", "warehouse-sign-in", "could not show the sign-in notice", { err: String(err) }))
 }
 
 let unsubscribe: (() => void) | undefined
@@ -130,5 +135,5 @@ export function install(deps: SignInNoticeDeps = defaultDeps): void {
 export function resetForTests(): void {
   unsubscribe?.()
   unsubscribe = undefined
-  origin = {}
+  origins.clear()
 }
diff --git a/packages/opencode/src/altimate/native/types.ts b/packages/opencode/src/altimate/native/types.ts
index 0e04f0b575..95ec525279 100644
--- a/packages/opencode/src/altimate/native/types.ts
+++ b/packages/opencode/src/altimate/native/types.ts
@@ -371,6 +371,8 @@ export interface WarehouseRemoveParams {
 export interface WarehouseRemoveResult {
   success: boolean
   error?: string
+  /** Set when the connection was removed but some of its stored credentials could not be deleted. */
+  warnings?: string[]
 }
 
 // --- Docker Discovery ---
diff --git a/packages/opencode/src/altimate/telemetry/index.ts b/packages/opencode/src/altimate/telemetry/index.ts
index 5c7c81c957..f350d9783c 100644
--- a/packages/opencode/src/altimate/telemetry/index.ts
+++ b/packages/opencode/src/altimate/telemetry/index.ts
@@ -2097,17 +2097,19 @@ export namespace Telemetry {
       const timer = setInterval(flush, FLUSH_INTERVAL_MS)
       if (typeof timer === "object" && timer && "unref" in timer) (timer as any).unref()
       flushTimer = timer
-      // altimate_change start — first-run health: watch for event-loop stalls wherever telemetry is
-      // live (CLI main thread and the TUI's server worker both init here), and drain anchor events
-      // that were tracked before init finished (first_launch always is) instead of leaving them to
-      // the 5 s interval a startup freeze would block.
-      startLoopMonitor()
+      // altimate_change start — first-run health: drain anchor events that were tracked before init
+      // finished (first_launch always is) instead of leaving them to the 5 s interval a startup freeze
+      // would block. The stall watcher starts in `finally`, telemetry or not.
       if (buffer.some((event) => ANCHOR_EVENTS.has(event.type))) void Telemetry.flush().catch(() => {})
       // altimate_change end
     } catch {
       buffer = []
     } finally {
       initDone = true
+      // altimate_change start — the stall watcher also writes each stall to opencode.log, which `debug bundle`
+      // reads, so it runs whether or not telemetry is on; with telemetry off its events are dropped by `track`.
+      startLoopMonitor()
+      // altimate_change end
     }
   }
 
@@ -2134,6 +2136,8 @@ export namespace Telemetry {
     "event_loop_stall",
     "altimate_base_registration",
     "session_start",
+    // Recorded before a warehouse connect: a connect that hangs is often killed within the 5 s flush interval.
+    "warehouse_connect_started",
   ])
   const LOOP_MONITOR_INTERVAL_MS = 250
   const LOOP_STALL_THRESHOLD_MS = 1_000
@@ -2202,9 +2206,19 @@ export namespace Telemetry {
    * `track` flushes it immediately as an anchor event.
    */
   export function startLoopMonitor(opts: { intervalMs?: number; thresholdMs?: number } = {}) {
-    if (loopTimer) return
-    const interval = opts.intervalMs ?? LOOP_MONITOR_INTERVAL_MS
-    const threshold = opts.thresholdMs ?? LOOP_STALL_THRESHOLD_MS
+    // altimate_change start — `init()` now starts the watcher with defaults even with telemetry off, so a caller
+    // that asks for specific settings replaces it rather than silently keeping the running one. A plain call stays
+    // idempotent.
+    // An option not given keeps the running watcher's value (or the default); it restarts only when the
+    // resulting settings differ.
+    const interval = opts.intervalMs ?? loopSettings?.interval ?? LOOP_MONITOR_INTERVAL_MS
+    const threshold = opts.thresholdMs ?? loopSettings?.threshold ?? LOOP_STALL_THRESHOLD_MS
+    if (loopTimer) {
+      if (loopSettings?.interval === interval && loopSettings?.threshold === threshold) return
+      stopLoopMonitor()
+    }
+    loopSettings = { interval, threshold }
+    // altimate_change end
     const thread: "main" | "worker" = isMainThread ? "main" : "worker"
     loopExpectedAt = performance.now() + interval
     const timer = setInterval(() => {
@@ -2226,8 +2240,12 @@ export namespace Telemetry {
   export function stopLoopMonitor() {
     if (loopTimer) clearInterval(loopTimer)
     loopTimer = undefined
+    loopSettings = undefined
   }
 
+  /** The running watcher's settings, so a later call that gives only one option keeps the other. */
+  let loopSettings: { interval: number; threshold: number } | undefined
+
   /** Test seam: the first-run latches are process-lifetime state and would otherwise leak across suites. */
   export function resetFirstRunStateForTest() {
     stopLoopMonitor()
diff --git a/packages/opencode/src/altimate/tools/warehouse-remove.ts b/packages/opencode/src/altimate/tools/warehouse-remove.ts
index 2d6469d359..035ae4aff3 100644
--- a/packages/opencode/src/altimate/tools/warehouse-remove.ts
+++ b/packages/opencode/src/altimate/tools/warehouse-remove.ts
@@ -12,6 +12,14 @@ export const WarehouseRemoveTool = Tool.define("warehouse_remove", {
       const result = await Dispatcher.call("warehouse.remove", { name: args.name })
 
       if (result.success) {
+        // A credential the system store refused to delete would be used again by a later connection of this name.
+        if (result.warnings?.length) {
+          return {
+            title: `Remove '${args.name}': OK, credentials may remain`,
+            metadata: { success: true, warnings: result.warnings },
+            output: `Removed warehouse '${args.name}'; some of its stored credentials may remain:\n${result.warnings.join("\n")}`,
+          }
+        }
         return {
           title: `Remove '${args.name}': OK`,
           metadata: { success: true },
diff --git a/packages/opencode/src/altimate/util/file-log.ts b/packages/opencode/src/altimate/util/file-log.ts
index baa843b3f6..c6e6fed666 100644
--- a/packages/opencode/src/altimate/util/file-log.ts
+++ b/packages/opencode/src/altimate/util/file-log.ts
@@ -14,11 +14,19 @@ import { runID } from "@opencode-ai/core/observability/shared"
 
 export type FileLogLevel = "DEBUG" | "INFO" | "WARN" | "ERROR"
 
+/** The log file (inode) last made owner-only. A rotated or replaced log is a new inode and is checked again. */
+let restrictedInode: number | undefined
+
 function format(value: unknown): string {
   const text = typeof value === "string" ? value : JSON.stringify(value) ?? String(value)
   return /^[^\s="\\]+$/.test(text) ? text : JSON.stringify(text)
 }
 
+/** Lets a test check the permission fix on a log file another writer already created. */
+export function resetPermissionCheckForTests(): void {
+  restrictedInode = undefined
+}
+
 /** One log line; `service` is written first so lines are easy to find. Never throws. */
 export function fileLog(level: FileLogLevel, service: string, message: string, fields: Record<string, unknown> = {}): void {
   try {
@@ -30,7 +38,16 @@ export function fileLog(level: FileLogLevel, service: string, message: string, f
       ["message", message],
       ...Object.entries(fields).filter(([, v]) => v !== undefined),
     ]
-    fs.appendFileSync(path.join(Global.Path.log, "opencode.log"), entries.map(([k, v]) => `${k}=${format(v)}`).join(" ") + "\n")
+    const file = path.join(Global.Path.log, "opencode.log")
+    fs.appendFileSync(file, entries.map(([k, v]) => `${k}=${format(v)}`).join(" ") + "\n", { mode: 0o600 })
+    // The file may have been created, or recreated after rotation, by another writer with the default (often
+    // world-readable) mode; it holds tool and connection details, so it is made readable by its owner only. Marked
+    // done only once the chmod succeeds, so a failure is retried on the next line.
+    const st = fs.statSync(file)
+    if (st.ino !== restrictedInode || (st.mode & 0o077) !== 0) {
+      if ((st.mode & 0o077) !== 0) fs.chmodSync(file, 0o600)
+      restrictedInode = st.ino
+    }
   } catch {
     // logging must never break the caller
   }
diff --git a/packages/opencode/src/cli/cmd/debug/bundle.ts b/packages/opencode/src/cli/cmd/debug/bundle.ts
index c475aca25f..17eb34338a 100644
--- a/packages/opencode/src/cli/cmd/debug/bundle.ts
+++ b/packages/opencode/src/cli/cmd/debug/bundle.ts
@@ -1,5 +1,6 @@
 // altimate_change start — `altimate debug bundle`: one readable, redacted report to send to support
 import fs from "fs"
+import { randomBytes } from "crypto"
 import path from "path"
 import { Effect } from "effect"
 import { effectCmd } from "../../effect-cmd"
@@ -33,12 +34,24 @@ export const BundleCommand = effectCmd({
     const report = redact(renderReport(facts, findings), redactContext())
     const stamp = facts.generatedAt.replace(/[:.]/g, "-").replace(/-\d{3}Z$/, "Z")
     const file = path.resolve(args.output ?? `altimate-debug-report-${stamp}.md`)
-    fs.writeFileSync(file, report, { mode: 0o600 })
-    // `mode` only applies to a new file; an existing one keeps its permissions otherwise.
+    // Written to a new owner-only file beside the destination, then renamed over it: writing into an existing
+    // file would keep that file's permissions while the report is in it, and follow a symlink at that path.
+    const temp = path.join(path.dirname(file), `.${path.basename(file)}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`)
+    let created = false
     try {
-      fs.chmodSync(file, 0o600)
-    } catch {
-      // not a filesystem that supports it
+      // Opened (exclusively) before writing, so a write that fails part-way still leaves a file this run owns.
+      const fd = fs.openSync(temp, "wx", 0o600)
+      created = true
+      try {
+        fs.writeFileSync(fd, report)
+      } finally {
+        fs.closeSync(fd)
+      }
+      fs.renameSync(temp, file)
+    } catch (err) {
+      // Only a file this run created is removed: `wx` failing means the name belonged to someone else.
+      if (created) fs.rmSync(temp, { force: true })
+      throw err
     }
     const problems = findings.filter((f) => f.severity === "problem").length
     process.stdout.write(
diff --git a/packages/opencode/src/index.ts b/packages/opencode/src/index.ts
index ab9daa41cd..ef7d01c2d3 100644
--- a/packages/opencode/src/index.ts
+++ b/packages/opencode/src/index.ts
@@ -62,6 +62,7 @@ import { Telemetry } from "./telemetry"
 import { showWelcomeBannerIfNeeded } from "./cli/welcome"
 // altimate_change start — debug mode
 import { isDebugMode, logStartup } from "@/altimate/debug/mode"
+import { Log as AltimateLog } from "@/altimate/util/log"
 // altimate_change end
 // altimate_change end
 
@@ -175,10 +176,16 @@ let cli = yargs(args)
     const firstPositional = String((opts as { _?: unknown[] })._?.[0] ?? "")
     Telemetry.setCommand(CLI_COMMAND_NAMES.has(firstPositional) ? firstPositional : "tui")
     // Debug mode: more detail in the log; and every start records its version in the log.
-    if (isDebugMode() && !opts.logLevel) process.env.OPENCODE_LOG_LEVEL = "DEBUG"
+    if (isDebugMode() && !opts.logLevel) {
+      process.env.OPENCODE_LOG_LEVEL = "DEBUG"
+      // The altimate log shim read its level when it was imported, before this ran.
+      AltimateLog.setLevel("DEBUG")
+    }
     logStartup(InstallationVersion, { thread: "main", command: CLI_COMMAND_NAMES.has(firstPositional) ? firstPositional : "tui" })
     // `debug bundle --no-network` promises no network access; telemetry would send its events.
-    if (!(firstPositional === "debug" && process.argv.includes("--no-network"))) Telemetry.init().catch(() => {})
+    // Any form of "no network" counts (`--no-network`, `--network=false`, `--network false`), as parsed by yargs.
+    const noNetwork = firstPositional === "debug" && (opts as { network?: unknown }).network === false
+    if (!noNetwork) Telemetry.init().catch(() => {})
     // altimate_change end
   })
   .usage("")
diff --git a/packages/opencode/test/altimate/credential-store-backend.test.ts b/packages/opencode/test/altimate/credential-store-backend.test.ts
index f3fa0058f0..5d750d0017 100644
--- a/packages/opencode/test/altimate/credential-store-backend.test.ts
+++ b/packages/opencode/test/altimate/credential-store-backend.test.ts
@@ -4,7 +4,10 @@
  * credential was stripped from the saved connection, so a connection worked in
  * the session that added it and failed after a restart.
  */
-import { afterEach, describe, expect, test } from "bun:test"
+import { afterEach, beforeEach, describe, expect, test } from "bun:test"
+import fs from "fs"
+import os from "os"
+import path from "path"
 import * as CredentialStore from "../../src/altimate/native/connections/credential-store"
 import * as Registry from "../../src/altimate/native/connections/registry"
 
@@ -77,54 +80,6 @@ describe("credential store with an OS backend", () => {
     expect(await CredentialStore.deleteCredential("pg", "password")).toBe(false)
   })
 
-  test("re-saving a connection under the same name drops secrets the new config no longer has", async () => {
-    // Key-pair first, then the same name switched to browser sign-in: the old key must not come back,
-    // because the driver tries key-pair before any other method.
-    const { store, backend } = memoryBackend()
-    CredentialStore.setSecretBackendForTests(backend)
-    await CredentialStore.saveConnection("sf", { type: "snowflake", account: "a", user: "u", private_key: "-----BEGIN PRIVATE KEY-----x" } as any)
-    expect(store.has("sf/private_key")).toBe(true)
-
-    const { sanitized } = await CredentialStore.saveConnection("sf", { type: "snowflake", account: "a", user: "u", authenticator: "externalbrowser" } as any)
-    expect(store.has("sf/private_key")).toBe(false)
-    expect((await CredentialStore.resolveConfig("sf", sanitized)).private_key).toBeUndefined()
-  })
-
-  test("a re-save whose new secret could not be stored keeps the old ones", async () => {
-    const { store, backend } = memoryBackend()
-    CredentialStore.setSecretBackendForTests(backend)
-    await CredentialStore.saveConnection("pg", { type: "postgres", password: "old", ssl_key: "k" } as any)
-    CredentialStore.setSecretBackendForTests({ ...backend, set: async () => { throw new Error("keychain locked") } })
-    const { warnings } = await CredentialStore.saveConnection("pg", { type: "postgres", password: "new" } as any)
-    expect(warnings.length).toBe(1)
-    expect(store.get("pg/password")).toBe("old")
-    expect(store.get("pg/ssl_key")).toBe("k")
-  })
-
-  test("removing a connection removes its secrets from the OS store", async () => {
-    const { store, backend } = memoryBackend()
-    CredentialStore.setSecretBackendForTests(backend)
-    const name = `rm_${Date.now()}`
-    expect((await Registry.add(name, { type: "postgres", host: "h", user: "u", password: "s3cret" } as any)).success).toBe(true)
-    expect(store.get(`${name}/password`)).toBe("s3cret")
-    expect((await Registry.remove(name)).success).toBe(true)
-    expect([...store.keys()].filter((k) => k.startsWith(`${name}/`))).toEqual([])
-  })
-
-  test("a connection still defined by an env var keeps its secrets when the saved copy is removed", async () => {
-    const { store, backend } = memoryBackend()
-    CredentialStore.setSecretBackendForTests(backend)
-    const name = `envkeep_${Date.now()}`
-    await Registry.add(name, { type: "postgres", host: "h", user: "u", password: "s3cret" } as any)
-    process.env[`ALTIMATE_CODE_CONN_${name.toUpperCase()}`] = JSON.stringify({ type: "postgres", host: "h", user: "u" })
-    try {
-      await Registry.remove(name)
-      expect(store.get(`${name}/password`)).toBe("s3cret")
-    } finally {
-      delete process.env[`ALTIMATE_CODE_CONN_${name.toUpperCase()}`]
-    }
-  })
-
   test("the Bun.secrets adapter calls the API in its object form and maps its results", async () => {
     const calls: unknown[] = []
     const values = new Map<string, string>()
@@ -160,3 +115,124 @@ describe("credential store with an OS backend", () => {
     expect(await CredentialStore.storeCredential("pg", "password", "x")).toBe(false)
   })
 })
+
+// Registry.add/remove write `~/.altimate-code/connections.json`; HOME is pointed at a temporary folder so these
+// tests never touch the developer's real connections.
+describe("saving and removing connections", () => {
+  // Global.Path.home follows OPENCODE_TEST_HOME, which the test preload sets; os.homedir() is cached by Bun and
+  // ignores a changed HOME, so the registry must not use it.
+  let home: string
+  const prior = process.env.OPENCODE_TEST_HOME
+  beforeEach(() => {
+    home = fs.mkdtempSync(path.join(os.tmpdir(), "cred-home-"))
+    process.env.OPENCODE_TEST_HOME = home
+  })
+  afterEach(() => {
+    if (prior === undefined) delete process.env.OPENCODE_TEST_HOME
+    else process.env.OPENCODE_TEST_HOME = prior
+    fs.rmSync(home, { recursive: true, force: true })
+  })
+  const saved = () => path.join(home, ".altimate-code", "connections.json")
+
+  test("writes go to the test home, never the real one", async () => {
+    CredentialStore.setSecretBackendForTests(memoryBackend().backend)
+    const real = path.join(os.homedir(), ".altimate-code", "connections.json")
+    const before = fs.existsSync(real) ? fs.readFileSync(real, "utf8") : null
+    expect((await Registry.add("iso_check", { type: "postgres", host: "h", user: "u", password: "p" } as any)).success).toBe(true)
+    expect(JSON.parse(fs.readFileSync(saved(), "utf8")).iso_check).toBeDefined()
+    expect(fs.existsSync(real) ? fs.readFileSync(real, "utf8") : null).toBe(before)
+  })
+
+  test("re-saving under the same name drops secrets the new config no longer has", async () => {
+    // Key-pair, then the same name switched to browser sign-in: the old key must not come back, because the
+    // driver tries key-pair before any other method.
+    const { store, backend } = memoryBackend()
+    CredentialStore.setSecretBackendForTests(backend)
+    await Registry.add("sf", { type: "snowflake", account: "a", user: "u", private_key: "-----BEGIN PRIVATE KEY-----x" } as any)
+    expect(store.has("sf/private_key")).toBe(true)
+    await Registry.add("sf", { type: "snowflake", account: "a", user: "u", authenticator: "externalbrowser" } as any)
+    expect(store.has("sf/private_key")).toBe(false)
+  })
+
+  test("old secrets are only removed once the new config is on disk", async () => {
+    const { store, backend } = memoryBackend()
+    CredentialStore.setSecretBackendForTests(backend)
+    await Registry.add("sf", { type: "snowflake", account: "a", user: "u", private_key: "-----BEGIN PRIVATE KEY-----x" } as any)
+    // A directory where the config file goes makes the write fail for every user, root included.
+    fs.rmSync(saved())
+    fs.mkdirSync(saved())
+    const r = await Registry.add("sf", { type: "snowflake", account: "a", user: "u", authenticator: "externalbrowser" } as any)
+    expect(r.success).toBe(false)
+    expect(store.has("sf/private_key")).toBe(true)
+  })
+
+  test("a secret that could not be stored keeps its old value; secrets the new config dropped still go", async () => {
+    const { store, backend } = memoryBackend()
+    CredentialStore.setSecretBackendForTests(backend)
+    await Registry.add("pg", { type: "postgres", host: "h", user: "u", password: "old", ssl_key: "k" } as any)
+    CredentialStore.setSecretBackendForTests({ ...backend, set: async () => { throw new Error("keychain locked") } })
+    const r = await Registry.add("pg", { type: "postgres", host: "h", user: "u", password: "new" } as any)
+    expect(r.warnings?.length).toBe(1)
+    expect(store.get("pg/password")).toBe("old")
+    expect(store.has("pg/ssl_key")).toBe(false)
+  })
+
+  test("a secret the store refuses to delete is reported, not silently kept", async () => {
+    const { store, backend } = memoryBackend()
+    CredentialStore.setSecretBackendForTests(backend)
+    await Registry.add("sf", { type: "snowflake", account: "a", user: "u", private_key: "-----BEGIN PRIVATE KEY-----x" } as any)
+    CredentialStore.setSecretBackendForTests({ ...backend, delete: async () => false })
+    const r = await Registry.add("sf", { type: "snowflake", account: "a", user: "u", authenticator: "externalbrowser" } as any)
+    expect(r.warnings?.join("\n")).toContain("Could not confirm that 'private_key'")
+    expect(store.has("sf/private_key")).toBe(true)
+    const removed = await Registry.remove("sf")
+    expect(removed.warnings?.join("\n")).toContain("Could not confirm that 'private_key'")
+  })
+
+  test("removing a connection removes its secrets from the OS store", async () => {
+    const { store, backend } = memoryBackend()
+    CredentialStore.setSecretBackendForTests(backend)
+    expect((await Registry.add("rm_me", { type: "postgres", host: "h", user: "u", password: "s3cret" } as any)).success).toBe(true)
+    expect(store.get("rm_me/password")).toBe("s3cret")
+    expect((await Registry.remove("rm_me")).success).toBe(true)
+    expect([...store.keys()].filter((k) => k.startsWith("rm_me/"))).toEqual([])
+  })
+
+  test("a connection named like an object property is removed with its secrets", async () => {
+    const { store, backend } = memoryBackend()
+    CredentialStore.setSecretBackendForTests(backend)
+    await Registry.add("constructor", { type: "postgres", host: "h", user: "u", password: "s3cret" } as any)
+    await Registry.remove("constructor")
+    expect(store.has("constructor/password")).toBe(false)
+  })
+
+  test("a connection still defined by an env var keeps its secrets when the saved copy is removed", async () => {
+    const { store, backend } = memoryBackend()
+    CredentialStore.setSecretBackendForTests(backend)
+    await Registry.add("envkeep", { type: "postgres", host: "h", user: "u", password: "s3cret" } as any)
+    const prior = process.env.ALTIMATE_CODE_CONN_ENVKEEP
+    process.env.ALTIMATE_CODE_CONN_ENVKEEP = JSON.stringify({ type: "postgres", host: "h", user: "u" })
+    try {
+      await Registry.remove("envkeep")
+      expect(store.get("envkeep/password")).toBe("s3cret")
+    } finally {
+      if (prior === undefined) delete process.env.ALTIMATE_CODE_CONN_ENVKEEP
+      else process.env.ALTIMATE_CODE_CONN_ENVKEEP = prior
+    }
+  })
+
+  test("a secret the store cannot read is still deleted, not mistaken for absent", async () => {
+    const { store, backend } = memoryBackend()
+    CredentialStore.setSecretBackendForTests(backend)
+    await Registry.add("unreadable", { type: "postgres", host: "h", user: "u", password: "s3cret" } as any)
+    CredentialStore.setSecretBackendForTests({ ...backend, get: async () => { throw new Error("keychain locked") } })
+    await Registry.remove("unreadable")
+    expect(store.has("unreadable/password")).toBe(false)
+  })
+
+  test("the fallback hint shows how to set a name a shell assignment cannot use", async () => {
+    CredentialStore.setSecretBackendForTests(null)
+    const { warnings } = await CredentialStore.saveConnection("prod-sf", { type: "snowflake", password: "p" } as any)
+    expect(warnings[0]).toContain("env 'ALTIMATE_CODE_CONN_PROD-SF=")
+  })
+})
diff --git a/packages/opencode/test/altimate/debug/collect.test.ts b/packages/opencode/test/altimate/debug/collect.test.ts
index 9aeb7bf488..54d4a8c6de 100644
--- a/packages/opencode/test/altimate/debug/collect.test.ts
+++ b/packages/opencode/test/altimate/debug/collect.test.ts
@@ -3,7 +3,7 @@ import { describe, expect, test } from "bun:test"
 import fs from "fs"
 import os from "os"
 import path from "path"
-import { connectionFact, mcpFacts, pidAlive, probe } from "../../../src/altimate/debug/collect"
+import { configFiles, connectionFact, credentialFieldsFor, mcpFacts, pidAlive, probe } from "../../../src/altimate/debug/collect"
 import { detectProblems } from "../../../src/altimate/debug/report"
 
 describe("connection facts", () => {
@@ -76,17 +76,114 @@ describe("MCP servers", () => {
       fs.mkdirSync(path.join(project, ".altimate-code"), { recursive: true })
       fs.writeFileSync(path.join(global, "altimate-code.json"), JSON.stringify({ mcp: { dbt: { type: "local" }, gh: { type: "remote" } } }))
       fs.writeFileSync(path.join(project, ".altimate-code", "altimate-code.jsonc"), '{ // comment\n "mcp": { "gh": { "type": "remote", "enabled": false } } }')
-      expect(mcpFacts({ global, project })).toEqual([
+      const home = path.join(root, "home")
+      expect(mcpFacts({ global, cwd: project, home })).toEqual([
         { name: "dbt", type: "local", enabled: true },
         { name: "gh", type: "remote", enabled: false },
       ])
-      expect(mcpFacts({ global: path.join(root, "none"), project: path.join(root, "none") })).toBeUndefined()
+      expect(mcpFacts({ global: path.join(root, "none"), cwd: path.join(root, "none"), home })).toBeUndefined()
     } finally {
       fs.rmSync(root, { recursive: true, force: true })
     }
   })
 })
 
+describe("MCP sources the loader uses", () => {
+  test("a partial override merges with the earlier entry; mcpServers, ancestors, extra file and inline content count", () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "dbg-mcp2-"))
+    try {
+      const global = path.join(root, "g")
+      const repo = path.join(root, "repo")
+      const nested = path.join(repo, "a", "b")
+      fs.mkdirSync(global, { recursive: true })
+      fs.mkdirSync(path.join(repo, ".git"), { recursive: true })
+      fs.mkdirSync(nested, { recursive: true })
+      fs.writeFileSync(path.join(global, "opencode.json"), JSON.stringify({ mcp: { dbt: { type: "local", enabled: false } } }))
+      // At the repo root, run from a nested folder: still found.
+      fs.writeFileSync(path.join(repo, "opencode.json"), JSON.stringify({ mcpServers: { gh: { type: "remote" } } }))
+      // Only `enabled` overridden: the type from the global file is kept.
+      fs.writeFileSync(path.join(nested, "opencode.json"), JSON.stringify({ mcp: { dbt: { enabled: true } } }))
+      const extra = path.join(root, "extra.json")
+      fs.writeFileSync(extra, JSON.stringify({ mcp: { lint: { type: "local" } } }))
+      const facts = mcpFacts({ global, cwd: nested, home: path.join(root, "h"), file: extra, content: '{"mcp":{"inline":{"type":"remote"}}}' })
+      expect(facts).toEqual([
+        { name: "dbt", type: "local", enabled: true },
+        { name: "gh", type: "remote", enabled: true },
+        { name: "inline", type: "remote", enabled: true },
+        { name: "lint", type: "local", enabled: true },
+      ])
+      // .opencode is read after .altimate-code, as the loader does.
+      const files = configFiles({ global, cwd: nested, home: path.join(root, "h") })
+      expect(files.indexOf(path.join(nested, ".opencode", "opencode.json"))).toBeGreaterThan(files.indexOf(path.join(nested, ".altimate-code", "opencode.json")))
+    } finally {
+      fs.rmSync(root, { recursive: true, force: true })
+    }
+  })
+})
+
+describe("MCP config as the loader normalises it", () => {
+  test("mcpServers only without mcp; types inferred from command or url; .jsonc wins in a folder; project files can be off", () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "dbg-mcp3-"))
+    try {
+      const global = path.join(root, "g")
+      const repo = path.join(root, "repo")
+      fs.mkdirSync(global, { recursive: true })
+      fs.mkdirSync(path.join(repo, ".git"), { recursive: true })
+      fs.writeFileSync(path.join(global, "opencode.json"), JSON.stringify({ mcp: { a: { command: "x" } }, mcpServers: { ghost: { url: "https://g" } } }))
+      fs.writeFileSync(path.join(repo, "opencode.json"), JSON.stringify({ mcp: { b: { enabled: true } } }))
+      fs.writeFileSync(path.join(repo, "opencode.jsonc"), '{ "mcp": { "b": { "url": "https://b", "enabled": false } } }')
+      const src = { global, cwd: repo, home: path.join(root, "h") }
+      expect(mcpFacts(src)).toEqual([
+        { name: "a", type: "local", enabled: true },
+        { name: "b", type: "remote", enabled: false },
+      ])
+      expect(mcpFacts({ ...src, noProject: true })).toEqual([{ name: "a", type: "local", enabled: true }])
+    } finally {
+      fs.rmSync(root, { recursive: true, force: true })
+    }
+  })
+
+  test("outside a repository every ancestor folder counts, as for the loader", () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "dbg-mcp4-"))
+    try {
+      const nested = path.join(root, "x", "y")
+      fs.mkdirSync(nested, { recursive: true })
+      const files = configFiles({ global: path.join(root, "g"), cwd: nested, home: path.join(root, "h") })
+      expect(files).toContain(path.join(root, "opencode.json"))
+    } finally {
+      fs.rmSync(root, { recursive: true, force: true })
+    }
+  })
+
+  test("the documented ALTIMATE_CLI_CONFIG name is read, as the loader reads it", () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "dbg-mcp5-"))
+    const prior = process.env.ALTIMATE_CLI_CONFIG
+    try {
+      const file = path.join(root, "custom.json")
+      fs.writeFileSync(file, JSON.stringify({ mcp: { documented: { command: "x" } } }))
+      process.env.ALTIMATE_CLI_CONFIG = file
+      expect(mcpFacts()?.some((m) => m.name === "documented")).toBe(true)
+    } finally {
+      if (prior === undefined) delete process.env.ALTIMATE_CLI_CONFIG
+      else process.env.ALTIMATE_CLI_CONFIG = prior
+      fs.rmSync(root, { recursive: true, force: true })
+    }
+  })
+})
+
+describe("credentials per warehouse type", () => {
+  test("a field the warehouse's driver does not read does not count as a sign-in", () => {
+    const secret = ["s3", "cr", "et"].join("")
+    const pg = connectionFact("pg", { type: "postgres", host: "h", user: "u" }, { type: "postgres", host: "h", user: "u", credentials_path: "/k.json" })
+    expect(pg.passwordAvailable).toBe(false)
+    const bq = connectionFact("bq", { type: "bigquery" }, { type: "bigquery", credentials_json: secret })
+    // BigQuery needs no sign-in check (default credentials are valid), but its key field is still recognised.
+    expect(bq.passwordAvailable).toBeUndefined()
+    expect(credentialFieldsFor("bigquery")).toContain("credentials_json")
+    expect(credentialFieldsFor("postgres")).toEqual(["password", "connection_string"])
+  })
+})
+
 describe("process liveness", () => {
   test("this process is alive; an unused pid is not", () => {
     expect(pidAlive(process.pid)).toBe(true)
diff --git a/packages/opencode/test/altimate/debug/mode.test.ts b/packages/opencode/test/altimate/debug/mode.test.ts
index a07fca1e05..7d3c2954ba 100644
--- a/packages/opencode/test/altimate/debug/mode.test.ts
+++ b/packages/opencode/test/altimate/debug/mode.test.ts
@@ -1,9 +1,18 @@
 // altimate_change start — debug mode tracing
-import { afterEach, describe, expect, test } from "bun:test"
+import { afterEach, beforeEach, describe, expect, test } from "bun:test"
+import fs from "fs"
+import path from "path"
+import { Global } from "@opencode-ai/core/global"
 import { isDebugMode, resetForTests, runningForTests, traceToolCall } from "../../../src/altimate/debug/mode"
 
-afterEach(() => {
+// The caller's own ALTIMATE_DEBUG is kept: each test sets what it needs and the original is restored afterwards.
+const originalDebug = process.env.ALTIMATE_DEBUG
+beforeEach(() => {
   delete process.env.ALTIMATE_DEBUG
+})
+afterEach(() => {
+  if (originalDebug === undefined) delete process.env.ALTIMATE_DEBUG
+  else process.env.ALTIMATE_DEBUG = originalDebug
   resetForTests()
 })
 
@@ -27,5 +36,25 @@ describe("debug mode", () => {
     end("success")
     expect(runningForTests().size).toBe(0)
   })
+
+  test("a repeated call id is two calls: ending one leaves the other running", () => {
+    process.env.ALTIMATE_DEBUG = "1"
+    const first = traceToolCall("bash", "dup")
+    traceToolCall("bash", "dup")
+    expect(runningForTests().size).toBe(2)
+    first("success")
+    expect(runningForTests().size).toBe(1)
+  })
+
+  test("a failed call's error text is redacted before it reaches the log, and the log is owner-only", () => {
+    process.env.ALTIMATE_DEBUG = "1"
+    const secret = ["hun", "ter", "42"].join("")
+    traceToolCall("warehouse_test", "c9")("error", `login failed: ${"pass" + "word"}=${secret} for snowflake://u:${secret}@acct`)
+    const file = path.join(Global.Path.log, "opencode.log")
+    const tail = fs.readFileSync(file, "utf8").split("\n").filter((l) => l.includes("call=c9")).join("\n")
+    expect(tail).toContain("tool end")
+    expect(tail).not.toContain(secret)
+    if (process.platform !== "win32") expect(fs.statSync(file).mode & 0o077).toBe(0)
+  })
 })
 // altimate_change end
diff --git a/packages/opencode/test/altimate/debug/report.test.ts b/packages/opencode/test/altimate/debug/report.test.ts
index 444c7d8a80..dc9de12544 100644
--- a/packages/opencode/test/altimate/debug/report.test.ts
+++ b/packages/opencode/test/altimate/debug/report.test.ts
@@ -118,8 +118,9 @@ describe("analyzeLog", () => {
 
   test("counts starts per day, MCP failures, sign-ins, stalls and snapshot errors", () => {
     expect(log.lines).toBe(13)
-    expect(log.starts).toBe(2)
-    expect(log.startsByDay).toEqual([{ day: "2026-10-02", starts: 2 }])
+    // Three processes: two older runs known only by their project loads, one with a start line.
+    expect(log.starts).toBe(3)
+    expect(log.startsByDay).toEqual([{ day: "2026-10-02", starts: 3 }])
     expect(log.mcpFailures).toEqual([{ server: "dbt", count: 2, lastError: "MCP error -32000: Connection closed" }])
     expect(log.signIns).toEqual({ waiting: 1, completed: 0, failed: 0 })
     expect(log.stalls).toEqual([{ at: "2026-10-02T11:12:03.000Z", thread: "worker", blockedMs: 42000 }])
@@ -132,6 +133,41 @@ describe("analyzeLog", () => {
     expect(log.debugTracing).toBe(true)
   })
 
+  test("a process counts once however many projects it loads; the TUI worker is not a second process", () => {
+    const l = analyzeLog(
+      parseLog(
+        [
+          L("2026-10-03T09:00:00.000Z", "INFO", "m1", 'service=debug message="altimate-code started" thread=main pid=1'),
+          L("2026-10-03T09:00:01.000Z", "INFO", "w1", 'service=debug message="altimate-code started" thread=worker pid=1'),
+          L("2026-10-03T09:00:02.000Z", "INFO", "w1", 'message="creating instance" directory=/a'),
+          L("2026-10-03T09:00:03.000Z", "INFO", "w1", 'message="creating instance" directory=/b'),
+        ].join("\n"),
+      ),
+    )
+    expect(l.starts).toBe(1)
+  })
+
+  test("project loads with no run id are reported on their own, not counted as app starts", () => {
+    const l = analyzeLog(
+      parseLog(
+        [
+          'timestamp=2026-10-04T09:00:00.000Z level=INFO message="creating instance" directory=/a',
+          'timestamp=2026-10-04T09:00:01.000Z level=INFO message="creating instance" directory=/b',
+        ].join("\n"),
+      ),
+    )
+    expect(l.starts).toBe(0)
+    expect(l.unattributedLoads).toBe(2)
+    expect(renderReport(facts({ log: l }), [])).toContain("plus 2 project loads in older lines that cannot be tied to a process")
+  })
+
+  test("debug mode on with no tool calls is not reported as debug mode off", () => {
+    const l = analyzeLog(parseLog(L("2026-10-03T09:00:00.000Z", "INFO", "m1", 'service=debug message="altimate-code started" thread=main debug=true pid=1')))
+    const titles = detectProblems(facts({ log: l })).map((x) => x.title)
+    expect(titles).toContain("Debug mode was on, but no tool calls were traced")
+    expect(titles).not.toContain("Debug mode was not on")
+  })
+
   test("repeats of one warning collapse into one row", () => {
     const mcp = log.problems.find((p) => p.template.startsWith("server unavailable"))
     expect(mcp?.count).toBe(2)
diff --git a/packages/opencode/test/altimate/util-file-log.test.ts b/packages/opencode/test/altimate/util-file-log.test.ts
new file mode 100644
index 0000000000..eed1cb1555
--- /dev/null
+++ b/packages/opencode/test/altimate/util-file-log.test.ts
@@ -0,0 +1,27 @@
+// altimate_change - new file
+import { expect, test } from "bun:test"
+import fs from "fs"
+import path from "path"
+import { Global } from "@opencode-ai/core/global"
+import { fileLog, resetPermissionCheckForTests } from "../../src/altimate/util/file-log"
+
+test.skipIf(process.platform === "win32")("a log file another writer created world-readable is made owner-only", () => {
+  const file = path.join(Global.Path.log, "opencode.log")
+  fs.mkdirSync(path.dirname(file), { recursive: true })
+  fs.appendFileSync(file, "")
+  fs.chmodSync(file, 0o644)
+  resetPermissionCheckForTests()
+  fileLog("INFO", "test", "permission check")
+  expect(fs.statSync(file).mode & 0o077).toBe(0)
+})
+
+test.skipIf(process.platform === "win32")("a log replaced after rotation is made owner-only too", () => {
+  const file = path.join(Global.Path.log, "opencode.log")
+  resetPermissionCheckForTests()
+  fileLog("INFO", "test", "before rotation")
+  fs.rmSync(file)
+  fs.writeFileSync(file, "", { mode: 0o644 })
+  fs.chmodSync(file, 0o644)
+  fileLog("INFO", "test", "after rotation")
+  expect(fs.statSync(file).mode & 0o077).toBe(0)
+})
diff --git a/packages/opencode/test/altimate/warehouse-sign-in-notice.test.ts b/packages/opencode/test/altimate/warehouse-sign-in-notice.test.ts
index 192e27317a..c4471abb35 100644
--- a/packages/opencode/test/altimate/warehouse-sign-in-notice.test.ts
+++ b/packages/opencode/test/altimate/warehouse-sign-in-notice.test.ts
@@ -30,13 +30,25 @@ describe("browser sign-in notice", () => {
     // the connect began and publishes there.
     SignInNotice.resetForTests()
     const seen: any[] = []
-    await WorkspaceContext.provide({ workspaceID: "wrk_signin", fn: () => SignInNotice.rememberOrigin() })
+    await WorkspaceContext.provide({ workspaceID: "wrk_signin", fn: () => SignInNotice.rememberOrigin(waiting.account) })
     SignInNotice.handle(waiting, { headless: () => false, toast: async (_t, from) => void seen.push(from), printLine: () => {} })
     expect(seen).toHaveLength(1)
     expect(seen[0].workspace).toBe("wrk_signin")
     SignInNotice.resetForTests()
   })
 
+  test("overlapping connects to different accounts each reach their own workspace", async () => {
+    SignInNotice.resetForTests()
+    const seen: any[] = []
+    const d = { headless: () => false, toast: async (t: any, from: any) => void seen.push([t.message, from.workspace]), printLine: () => {} }
+    await WorkspaceContext.provide({ workspaceID: "wrk_a", fn: () => SignInNotice.rememberOrigin("acct-a") })
+    await WorkspaceContext.provide({ workspaceID: "wrk_b", fn: () => SignInNotice.rememberOrigin("acct-b") })
+    SignInNotice.handle({ ...waiting, account: "acct-a" }, d)
+    SignInNotice.handle({ ...waiting, account: "acct-b" }, d)
+    expect(seen.map((x) => x[1])).toEqual(["wrk_a", "wrk_b"])
+    SignInNotice.resetForTests()
+  })
+
   test("the TUI shows the sign-in for the whole wait, with the account and the link", () => {
     const d = deps(false)
     SignInNotice.handle(waiting, d.deps)
@@ -59,11 +71,14 @@ describe("browser sign-in notice", () => {
     expect(d.lines[0]).toStartWith("Waiting for sign-in: Sign in to Snowflake")
   })
 
-  test("a completed sign-in is confirmed briefly; a failed one is left to the tool's error", () => {
+  test("a completed sign-in is confirmed briefly; a failed one replaces the waiting toast at once", () => {
     const d = deps(false)
     SignInNotice.handle({ warehouse: "snowflake", account: "a", phase: "completed" }, d.deps)
     SignInNotice.handle({ warehouse: "snowflake", account: "a", phase: "failed" }, d.deps)
-    expect(d.toasts.map((t) => t.variant)).toEqual(["success"])
+    expect(d.toasts.map((t) => t.variant)).toEqual(["success", "error"])
+    // Not "sign-in did not complete": the driver reports any connect error after the page opened this way.
+    expect(d.toasts[1].title).toBe("Connection failed")
+    expect(d.toasts[1].duration).toBeLessThan(10_000)
   })
 
   test("control characters from the identity provider never reach the screen", () => {
@@ -80,6 +95,8 @@ describe("connection attempts are recorded before connecting", () => {
   afterAll(() => {
     trackSpy.mockRestore()
     ctxSpy.mockRestore()
+    // Registry.get installs the process-wide sign-in listener; later test files must not inherit it.
+    SignInNotice.resetForTests()
   })
   beforeEach(() => {
     Registry.reset()
@@ -94,6 +111,12 @@ describe("connection attempts are recorded before connecting", () => {
     expect(tracked[0].auth_method).toBe(tracked[1].auth_method)
   })
 
+  test("a saved connection with no type still reports one on its start event", async () => {
+    Registry.setConfigs({ notype: { account: "a" } as any })
+    await Registry.get("notype").catch(() => {})
+    expect(tracked.find((e) => e.type === "warehouse_connect_started")?.warehouse_type).toBe("unknown")
+  })
+
   test("the driver's SSO and connect-limit errors get their own categories", () => {
     expect(
       Registry.categorizeConnectionError(
diff --git a/packages/opencode/test/skill/release-v0.11.1-adversarial.test.ts b/packages/opencode/test/skill/release-v0.11.1-adversarial.test.ts
index 8712b832c1..f334161318 100644
--- a/packages/opencode/test/skill/release-v0.11.1-adversarial.test.ts
+++ b/packages/opencode/test/skill/release-v0.11.1-adversarial.test.ts
@@ -344,6 +344,23 @@ describe("startLoopMonitor — LOOP_STALL_MAX_EVENTS cap and idempotency", () =>
     }
   }, 10_000)
 
+  test("explicit settings replace a watcher already started with the defaults (init starts one)", async () => {
+    const events: Telemetry.Event[] = []
+    const spy = spyOn(Telemetry, "track").mockImplementation((event) => void events.push(event))
+    try {
+      Telemetry.startLoopMonitor() // what init() does
+      Telemetry.startLoopMonitor({ intervalMs: 5, thresholdMs: 3 })
+      for (let i = 0; i < 10; i++) {
+        blockFor(8)
+        await new Promise((resolve) => setTimeout(resolve, 1))
+      }
+      expect(events.filter((e) => e.type === "event_loop_stall").length).toBeGreaterThan(0)
+    } finally {
+      spy.mockRestore()
+      Telemetry.stopLoopMonitor()
+    }
+  }, 10_000)
+
   test("stopLoopMonitor before any start is a safe no-op", () => {
     Telemetry.resetFirstRunStateForTest()
     expect(() => Telemetry.stopLoopMonitor()).not.toThrow()
diff --git a/packages/tui/src/app.tsx b/packages/tui/src/app.tsx
index f825f5f60d..85ac8c470c 100644
--- a/packages/tui/src/app.tsx
+++ b/packages/tui/src/app.tsx
@@ -254,7 +254,7 @@ export const run = Effect.fn("Tui.run")(function* (input: TuiInput) {
       win32DisableProcessedInput()
       // altimate_change start — reset terminal modes if the process exits without the teardown below
       yield* Effect.acquireRelease(
-        Effect.sync(() => restoreTerminalOnUncleanExit(renderer)),
+        Effect.sync(() => restoreTerminalOnUncleanExit(renderer, { shutdown: () => destroyRenderer(renderer) })),
         (unregister) => Effect.sync(unregister),
       )
       // altimate_change end
diff --git a/packages/tui/src/util/terminal-restore.ts b/packages/tui/src/util/terminal-restore.ts
index 9f32b3434b..92709f00f9 100644
--- a/packages/tui/src/util/terminal-restore.ts
+++ b/packages/tui/src/util/terminal-restore.ts
@@ -20,12 +20,21 @@ export const TERMINAL_RESET =
   "\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1004l\x1b[?2004l\x1b[?2031l" +
   "\x1b[<u\x1b[>4;0m\x1b[?25h\x1b[?1049l"
 
+/** How long SIGTERM waits for the TUI's own shutdown before ending the process. */
+export const SIGTERM_GRACE_MS = 3_000
+
 export interface TerminalRestoreDeps {
   onExit: (fn: () => void) => () => void
   onTerminate: (fn: () => void) => () => void
+  /** The TUI's own graceful shutdown (the path SIGHUP takes), so its finalizers run. */
+  shutdown: () => void
+  /** Runs `fn` after `ms`; returns a cancel. */
+  later: (fn: () => void, ms: number) => () => void
   exit: (code: number) => void
   write: (text: string) => void
   isTTY: () => boolean
+  /** Leave raw input mode; the renderer's teardown does this on a clean exit. */
+  cookInput: () => void
 }
 
 const defaultDeps: TerminalRestoreDeps = {
@@ -37,18 +46,36 @@ const defaultDeps: TerminalRestoreDeps = {
     process.on("SIGTERM", fn)
     return () => process.off("SIGTERM", fn)
   },
+  shutdown: () => {},
+  later: (fn, ms) => {
+    const t = setTimeout(fn, ms)
+    ;(t as { unref?: () => void }).unref?.()
+    return () => clearTimeout(t)
+  },
   exit: (code) => process.exit(code),
   write: (text) => writeSync(1, text),
   isTTY: () => Boolean(process.stdout.isTTY),
+  cookInput: () => {
+    if (process.stdin.isTTY) process.stdin.setRawMode?.(false)
+  },
 }
 
 /** Registers the exit guard for `renderer`; returns the unregister. */
 export function restoreTerminalOnUncleanExit(
   renderer: { readonly isDestroyed: boolean },
-  deps: TerminalRestoreDeps = defaultDeps,
+  overrides: Partial<TerminalRestoreDeps> = {},
 ): () => void {
+  const deps = { ...defaultDeps, ...overrides }
   const restore = () => {
-    if (renderer.isDestroyed || !deps.isTTY()) return
+    if (renderer.isDestroyed) return
+    try {
+      // Without this the shell is left without echo or line editing. Done whether or not stdout is a terminal:
+      // stdin can be one while stdout is redirected.
+      deps.cookInput()
+    } catch {
+      // stdin already gone
+    }
+    if (!deps.isTTY()) return
     try {
       deps.write(TERMINAL_RESET)
     } catch {
@@ -56,12 +83,21 @@ export function restoreTerminalOnUncleanExit(
     }
   }
   const offExit = deps.onExit(restore)
-  // SIGTERM's default action ends the process without an `exit` event. Exiting from a listener instead fires it,
-  // so the restore above runs; 143 (128 + 15) is the status the default action would have given.
-  const offTerminate = deps.onTerminate(() => deps.exit(143))
+  // SIGTERM's default action ends the process with no cleanup at all. Take the TUI's own shutdown instead, as SIGHUP
+  // does, so its finalizers run; if that has not ended the process within the grace period, exit with 143 (the
+  // status the default action gives), which still runs the restore above.
+  let cancelFallback: (() => void) | undefined
+  const offTerminate = deps.onTerminate(() => {
+    deps.shutdown()
+    // One fallback however many SIGTERMs arrive, so the teardown's cancel covers it.
+    cancelFallback ??= deps.later(() => deps.exit(143), SIGTERM_GRACE_MS)
+  })
+  // Unregistered by the TUI's own teardown: a shutdown that completed in time cancels the fallback exit, which would
+  // otherwise end a host process that is still running.
   return () => {
     offExit()
     offTerminate()
+    cancelFallback?.()
   }
 }
 // altimate_change end
diff --git a/packages/tui/test/terminal-restore.test.ts b/packages/tui/test/terminal-restore.test.ts
index d5c1d6ae7a..f661377596 100644
--- a/packages/tui/test/terminal-restore.test.ts
+++ b/packages/tui/test/terminal-restore.test.ts
@@ -7,6 +7,9 @@ function harness(opts: { destroyed: boolean; tty?: boolean }) {
   let exitHandler: (() => void) | undefined
   let termHandler: (() => void) | undefined
   const exits: number[] = []
+  const shutdowns: number[] = []
+  const pending: Array<() => void> = []
+  const cooked: number[] = []
   const written: string[] = []
   const unregister = restoreTerminalOnUncleanExit(renderer, {
     onExit: (fn) => {
@@ -25,10 +28,26 @@ function harness(opts: { destroyed: boolean; tty?: boolean }) {
       exits.push(code)
       exitHandler?.() // process.exit fires the exit event
     },
+    shutdown: () => void shutdowns.push(1),
+    later: (fn) => {
+      pending.push(fn)
+      return () => pending.splice(pending.indexOf(fn), 1)
+    },
+    cookInput: () => void cooked.push(1),
     write: (t) => void written.push(t),
     isTTY: () => opts.tty ?? true,
   })
-  return { renderer, written, exits, exit: () => exitHandler?.(), term: () => termHandler?.(), unregister }
+  return {
+    renderer,
+    written,
+    exits,
+    shutdowns,
+    cooked,
+    exit: () => exitHandler?.(),
+    term: () => termHandler?.(),
+    elapse: () => pending.splice(0).forEach((fn) => fn()),
+    unregister,
+  }
 }
 
 describe("terminal restore on exit", () => {
@@ -48,12 +67,41 @@ describe("terminal restore on exit", () => {
     expect(h.written).toEqual([])
   })
 
-  test("SIGTERM restores the terminal and still ends the process with 143", () => {
-    // SIGTERM's default action ends the process without an `exit` event, so `kill <pid>` left the modes on.
+  test("SIGTERM takes the TUI's own shutdown first, and only exits (restoring the terminal) if that stalls", () => {
     const h = harness({ destroyed: false })
     h.term()
-    expect(h.written).toEqual([TERMINAL_RESET])
+    expect(h.shutdowns).toEqual([1])
+    expect(h.exits).toEqual([])
+    h.elapse() // the grace period passes with the process still up
     expect(h.exits).toEqual([143])
+    expect(h.written).toEqual([TERMINAL_RESET])
+  })
+
+  test("an unclean exit also takes stdin out of raw mode, even with stdout redirected", () => {
+    const h = harness({ destroyed: false })
+    h.exit()
+    expect(h.cooked).toEqual([1])
+    const redirected = harness({ destroyed: false, tty: false })
+    redirected.exit()
+    expect(redirected.cooked).toEqual([1])
+    expect(redirected.written).toEqual([])
+  })
+
+  test("repeated SIGTERMs arm one fallback, which the teardown cancels", () => {
+    const h = harness({ destroyed: false })
+    h.term()
+    h.term()
+    h.unregister()
+    h.elapse()
+    expect(h.exits).toEqual([])
+  })
+
+  test("a shutdown that finishes in time cancels the fallback exit", () => {
+    const h = harness({ destroyed: false })
+    h.term()
+    h.unregister() // the TUI's own teardown ran
+    h.elapse()
+    expect(h.exits).toEqual([])
   })
 
   test("unregistering removes both guards", () => {