diff --git a/‎CHANGELOG.md‎
Lines changed: 22 additions & 2 deletions b/‎CHANGELOG.md‎
Lines changed: 22 additions & 2 deletions
diff --git a/‎docs/docs/configure/skills.md‎
Lines changed: 2 additions & 2 deletions b/‎docs/docs/configure/skills.md‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎packages/opencode/src/altimate/native/schema-resolver.ts‎
Lines changed: 70 additions & 27 deletions b/‎packages/opencode/src/altimate/native/schema-resolver.ts‎
Lines changed: 70 additions & 27 deletions
@@ -5,6 +5,26 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.12.2] - 2026-09-22
+
+Promotes [0.12.2-beta.1] to `latest` — the six bug fixes below — plus four small fixes from this release's review. No new features. The beta was published earlier the same day and did not soak before promotion; the review below is what stood in for that.
+
+**Heads-up before upgrading (every user, not only the pilot):**
+
+- **Environment variables: the documented `ALTIMATE_CLI_*` name now wins when both spellings are set.** Before 0.12.2 most `ALTIMATE_CLI_*` names were silently ignored, so anything you set under one and forgot is live now. Two to check for in particular: `ALTIMATE_CLI_DB` (now redirects the session database — "my history is gone" after an upgrade means this), and `ALTIMATE_CLI_DISABLE_AUTOUPDATE=false` next to `OPENCODE_DISABLE_AUTOUPDATE=true` (the documented `false` now wins; before, either `true` disabled updates). `env | grep ALTIMATE_CLI_` before upgrading.
+- **Headless `run` exits 1 in one case that used to exit 0:** a turn whose last step produces no text — typically after a tool failed or was auto-rejected, but also after a tool that succeeded — and that stays silent when asked once more. A CI job gating on `run`'s exit code can go red with no change on your side — read the printed "No answer was produced" line; that run never had an answer, it just used to say nothing. (#1345)
+
+### Fixed (since the beta)
+
+- **`altimate_core_validate` no longer validates a wrong quoted reference on a lowercase-metadata warehouse.** The beta folded a quoted all-uppercase reference (`"SHIPPED_DATE"`) whenever the schema held the name in lowercase — right for Snowflake, where the metadata is uppercase and was folded, wrong for Postgres and DuckDB, where `shipped_date` held as written means `"SHIPPED_DATE"` is a different identifier and the query fails. The SQL is folded only for names the schema itself folded; lowercase metadata leaves the SQL exactly as written. Found and reproduced in this release's review.
+- **Headless `run` does not ask for a reply after a compaction step.** The "did the last step answer" counter now skips compaction steps, as the turn budget already did, so context management running after the final answer cannot trigger a spurious follow-up. (#1345 follow-up)
+- **New skill in the skills browser is `ctrl+o`, not `ctrl+e`** — `ctrl+e` is line-end in the filter box. (#1342 follow-up)
+- **The FinOps BigQuery note names the tool that reveals a connection's location** (`datamate_bigquery_list_database_connections`). Pilot only. (#1346 follow-up)
+
+### Known limitations
+
+- `altimate_core_validate`'s identifier folding carries no quote identity and does not parse the SQL: a quoted reference that happens to match a folded name (`"order_month"` against uppercase-stored `ORDER_MONTH` on Snowflake) validates although the warehouse would reject it; on a lowercase-folding warehouse an all-uppercase quoted-created identifier is treated as unquoted; and a column name that some table holds in lowercase as written is never folded for any table, so a quoted `"ID"` against a table whose `ID` was folded is reported missing (the pre-0.12.2 behaviour) rather than bound to the wrong table's column. All pinned by tests; a dialect input on the tool is the fix and is a follow-up.
+
 ## [0.12.2-beta.1] - 2026-09-22
 
 > **Beta channel release.** Publishes to the npm `beta` dist-tag; `latest` (0.12.1) is unaffected. Install: `npm i -g @altimateai/altimate-code@beta`.
@@ -14,11 +34,11 @@ Six bug fixes from the first headless triage of the workspace pilot and from the
 ### Fixed
 
 - **Every documented `ALTIMATE_CLI_*` environment variable is now read** — not only `YOLO` and `DISABLE_AUTOUPDATE`. `docs/docs/usage/cli.md` documents the flags under `ALTIMATE_CLI_*`, but most of the table (external-skill scanning, autocompact, default plugins, LSP download, models fetch, project config, prune, terminal title, Exa, the `EXPERIMENTAL*` family, `CONFIG`, `CONFIG_CONTENT`, `CONFIG_DIR`, `GIT_BASH_PATH`, `PERMISSION`, `SERVER_USERNAME`/`SERVER_PASSWORD`) was read under the `OPENCODE_*` spelling only, so the documented name silently did nothing. One rule now applies on every read path — the two flag modules, the Effect-config services skill discovery and server auth actually read, and the direct reads in config loading, `run --attach`, the legacy database path, the updater and the feature census. The documented name wins when both are set; an empty documented value counts as unset; the `OPENCODE_*` spellings keep working. (#1341, closes #1329)
-- **`/skills` opens the Altimate skills browser, and its actions work.** `/skills` used to open the plain core skill selector (two `/skills` rows in autocomplete; Enter took the wrong one), where ctrl+a did nothing because the plugin's global keybind was outranked by the open dialog. The browser's Actions / New / Install are dialog-level actions now — bound inside the dialog to ctrl+a / ctrl+e / ctrl+g, and rendered as footer buttons reachable with Tab, so no chord is required. Install moved off ctrl+i, which most terminals send as Tab. New and Install work with the list filtered to nothing (the create-from-filter flow), and the palette's "Skills" row and a configured `prompt_skills` keybind both open the browser. (#1342, closes #1328)
+- **`/skills` opens the Altimate skills browser, and its actions work.** `/skills` used to open the plain core skill selector (two `/skills` rows in autocomplete; Enter took the wrong one), where ctrl+a did nothing because the plugin's global keybind was outranked by the open dialog. The browser's Actions / New / Install are dialog-level actions now — bound inside the dialog to ctrl+a / ctrl+o / ctrl+g (the beta had New on ctrl+e, which is line-end in the filter box; 0.12.2 moved it), and rendered as footer buttons reachable with Tab, so no chord is required. Install moved off ctrl+i, which most terminals send as Tab. New and Install work with the list filtered to nothing (the create-from-filter flow), and the palette's "Skills" row and a configured `prompt_skills` keybind both open the browser. (#1342, closes #1328)
 - **`altimate_core_validate` no longer reports a correct query as `ColumnNotFound` against Snowflake metadata.** Warehouse metadata comes back uppercase; the engine compares unquoted identifiers in lowercase and quoted ones exactly. Metadata names are now folded to the engine's form, and quoted all-uppercase references in the SQL (dbt `quote_columns` style) are folded to meet them — only for names the schema actually holds, so a `"SHIPPED"` string literal is untouched. The same preparation applies to every operation that matches SQL against a schema (lint, explain, check, fix, rewrite, equivalence, lineage, and the `sql.*` handlers), generated SQL comes back in the caller's spelling, and a schema file in JSON/YAML is treated like an inline context. Without a schema — or with one that defines no tables — existence checks are skipped as the tool promises, instead of reporting every table missing or failing the call. Known limitation: the fold is dialect-blind; on a lowercase-folding warehouse an all-uppercase quoted-created identifier would be treated as unquoted. (#1343, closes #1333)
 - **"Remember this for the team" lands where teammates read it, and a one-shot `run` no longer loses the upload.** In a linked project the model reached for the engine's `datamate_*` memory store, which linked checkouts never read; the `## Altimate Workspace` section now names `altimate_memory_write` as the team's store once the workspace's memory is confirmed enabled (and not while the link is only "last known"), and the tool description says the same. `run` waits — bounded — for pending memory mirrors and archives before exiting, on a normal exit and, briefly, on Ctrl-C. Pilot only (`ALTIMATE_WORKSPACE=1`). (#1344, closes #1332)
 - **A headless `run` always ends with an answer.** When a tool call failed or was auto-rejected (nobody can approve in headless use) and the model stopped without text — or streamed a "Let me check…" preamble, called a tool, and then stopped — the process printed nothing and exited 0. `run` now asks for a reply once, naming the failed tool; if the model still says nothing, a synthesised line says so on stdout, in `--output` and as a `silent_turn` event in `--format json`, and the run exits 1. Tool diagnostics are not repeated into the follow-up prompt or the answer file. A follow-up that dies in transport reports the error instead of only an exit code. (#1345, closes #1334)
-- **FinOps tools in a linked project point at the workspace engine instead of failing bare.** `finops_warehouse_advice`, `finops_analyze_credits`, `finops_query_history`, `finops_expensive_queries` and the role tools resolve only local connections; in a project whose Snowflake connection lives in the workspace they failed four times before the model thought of the engine. The failure now says why and names the engine tool with the tables the operation reads (region-qualified for BigQuery), re-validated against the current link; in the end-to-end run the model pivoted after one failure. When the routing decision is unknown the failure says that too. Running the FinOps SQL through the engine itself is not in this release. (#1346, closes #1336)
+- **FinOps tools in a linked project point at the workspace engine instead of failing bare.** `finops_warehouse_advice`, `finops_analyze_credits`, `finops_query_history`, `finops_expensive_queries` and the role tools resolve only local connections; in a project whose Snowflake connection lives in the workspace they failed four times before the model thought of the engine. The failure now says why and names the engine tool with the tables the operation reads (region-qualified for BigQuery), re-validated against the current link; in the end-to-end run the model pivoted after one failure. When the routing decision is unknown the failure says that too. Pilot only (`ALTIMATE_WORKSPACE=1`): outside the pilot the failure text is unchanged. Running the FinOps SQL through the engine itself is not in this release. (#1346, closes #1336)
 
 ## [0.12.1] - 2026-09-21
 
 
@@ -211,12 +211,12 @@ Open the skill browser by typing `/skills` in the prompt (or `<leader>k`):
 |-----|--------|
 | Enter | Use — inserts `/<skill-name>` into the prompt |
 | `ctrl+a` | Actions — show, edit, test, remove, or publish the selected skill to the linked workspace (the publish row appears only with `ALTIMATE_WORKSPACE=1`) |
-| `ctrl+e` | New — scaffold a new skill + CLI tool (`ctrl+n` moves down the list, as in every dialog) |
+| `ctrl+o` | New — scaffold a new skill + CLI tool (`ctrl+n` moves down the list and `ctrl+e` is line-end in the filter box, as in every dialog) |
 | `ctrl+g` | Install a skill from a GitHub repo, URL, or local path (`ctrl+i` is Tab in most terminals, so it cannot be the chord) |
 | Tab / Shift+Tab | Move between the **Actions · New · Install** buttons in the footer, then Enter — the same three without a chord |
 | Esc | Back — returns to previous screen |
 
-**Create skill** (`ctrl+e`, or the **New** footer button):
+**Create skill** (`ctrl+o`, or the **New** footer button):
 
 ![Create Skill Dialog](../assets/images/skills/tui-skill-create.png)
 
 
@@ -169,15 +169,47 @@ export function foldQuotedIdentifierCase(sql: string, names?: ReadonlySet<string
   )
 }
 
-/** Every folded table key and column name in a definition, plus each dotted segment
- * of a table key, so `"DB"."SCHEMA"."ORDERS"` can meet a `db.schema.orders` key. */
-function schemaNames(def: { tables: Record<string, any> }): Set<string> {
+/** The names the schema fold actually changed — every table key and column name that
+ * `foldSchemaCase` stored differently from how the caller wrote it, in folded form,
+ * plus each dotted segment of a folded table key (so `"DB"."SCHEMA"."ORDERS"` can meet
+ * `db.schema.orders`; a column name's dots are not qualifiers). Only these may be folded
+ * in the SQL: a quoted `"SHIPPED_DATE"` against metadata that holds `shipped_date` as
+ * written is, on a lowercase-folding warehouse, a reference to a different, quoted
+ * identifier, and folding it would validate a query Postgres rejects.
+ *
+ * Two exclusions keep the set honest without parsing the SQL (which table a column
+ * reference belongs to is not known here): a name the fold kept as written because its
+ * folded form already existed in the same table (`ORDERS` beside `orders`, `ID` beside
+ * `id`) is not folded in the SQL, so `"ORDERS"` cannot be bound to the sibling object;
+ * and a column name that ANY table holds as written in lowercase is not folded either —
+ * with `a.id` never folded and `b.ID` folded, `"ID"` against `a` would otherwise be
+ * rewritten on the strength of a column in an unrelated table. The cost is a quoted
+ * `"ID"` against `b` staying as written (reported missing, the pre-fold behaviour); the
+ * alternative validated a query Postgres rejects. */
+function foldedNames(original: { tables: Record<string, any> }, folded: { tables: Record<string, any> }): Set<string> {
   const names = new Set<string>()
-  for (const [table, value] of Object.entries(def.tables ?? {})) {
-    names.add(table)
-    for (const segment of table.split(".")) names.add(segment)
-    if (Array.isArray(value?.columns)) for (const c of value.columns) if (typeof c?.name === "string") names.add(c.name)
+  const heldAsWritten = new Set<string>()
+  const candidates = new Set<string>()
+  for (const [table, value] of Object.entries(original.tables ?? {})) {
+    const key = foldIdentifierCase(table)
+    if (key !== table && Object.hasOwn(folded.tables, key) && !Object.hasOwn(folded.tables, table)) {
+      names.add(key)
+      for (const segment of key.split(".")) names.add(segment)
+    }
+    const stored = folded.tables[Object.hasOwn(folded.tables, table) ? table : key]
+    const storedNames = new Set<string>(
+      Array.isArray(stored?.columns) ? stored.columns.map((c: any) => c?.name).filter((n: unknown) => typeof n === "string") : [],
+    )
+    if (Array.isArray(value?.columns)) {
+      for (const c of value.columns) {
+        if (typeof c?.name !== "string") continue
+        const column = foldIdentifierCase(c.name)
+        if (column === c.name) heldAsWritten.add(c.name)
+        else if (storedNames.has(column) && !storedNames.has(c.name)) candidates.add(column)
+      }
+    }
   }
+  for (const column of candidates) if (!heldAsWritten.has(column)) names.add(column)
   return names
 }
 
@@ -259,21 +291,22 @@ export interface PreparedSql {
 export function prepareSql(sql: string, schemaPath?: string, schemaContext?: Record<string, any>): PreparedSql {
   const asIs = (other: string) => other
   const identity = <T>(value: T) => value
-  const folding = (def: { tables: Record<string, any> }, schema: Schema): PreparedSql => {
-    const names = schemaNames(def)
+  const folding = (original: { tables: Record<string, any> }, def: { tables: Record<string, any> }, schema: Schema): PreparedSql => {
+    const names = foldedNames(original, def)
     const folded = new Set<string>()
     const foldSql = (other: string) => foldQuotedIdentifierCase(other, names, folded)
     return { sql: foldSql(sql), schema, hasSchema: true, foldSql, unfold: (value) => unfoldValue(value, folded) }
   }
   if (schemaPath) {
     const loaded = loadSchemaFile(schemaPath)
-    if (loaded.folded && loaded.schema) return folding(loaded.folded, loaded.schema)
+    if (loaded.original && loaded.folded && loaded.schema) return folding(loaded.original, loaded.folded, loaded.schema)
     if (!loaded.schema) return { sql, schema: EMPTY_SCHEMA(), hasSchema: false, foldSql: asIs, unfold: identity }
     return { sql, schema: loaded.schema, hasSchema: true, foldSql: asIs, unfold: identity }
   }
   if (schemaProvided(undefined, schemaContext)) {
-    const def = normalizedSchemaDefinition(schemaContext!, { fold: true })
-    return folding(def, Schema.fromJson(JSON.stringify(def)))
+    const original = normalizedSchemaDefinition(schemaContext!)
+    const def = foldSchemaCase(original)
+    return folding(original, def, Schema.fromJson(JSON.stringify(def)))
   }
   return { sql, schema: EMPTY_SCHEMA(), hasSchema: false, foldSql: asIs, unfold: identity }
 }
@@ -293,29 +326,39 @@ function unfoldValue<T>(value: T, folded: ReadonlySet<string>): T {
 /** Quoted tokens (`"…"` or `` `…` ``) whose content is one this preparation folded go
  * back to uppercase — the spelling the caller wrote, since the fold only ever took an
  * all-uppercase name down. A lowercase quoted name the caller wrote themselves was
- * never recorded and is left alone. */
+ * never recorded and is left alone. The same spans the fold steps over (string
+ * literals, dollar strings, comments) are stepped over here too, so a literal whose
+ * value happens to read like a folded identifier is not changed. */
 function unfoldText(text: string, folded: ReadonlySet<string>): string {
-  return text.replace(/"([^"]*)"|`([^`]*)`/g, (match, dq?: string, bq?: string) => {
-    const quoted = dq ?? bq
-    if (quoted === undefined || !folded.has(quoted)) return match
-    const mark = match[0]
-    return `${mark}${quoted.toUpperCase()}${mark}`
-  })
+  return text.replace(
+    /(?<![A-Za-z0-9_$])\$([A-Za-z_][A-Za-z0-9_]*)?\$[\s\S]*?\$\1\$|[eE]'(?:[^'\\]|\\[\s\S]|'')*'|'(?:[^']|'')*'|--[^\n]*|\/\*[\s\S]*?\*\/|"((?:[^"]|"")*)"|`((?:[^`]|``)*)`/g,
+    (match, _tag, dq?: string, bq?: string) => {
+      const quoted = dq ?? bq
+      if (quoted === undefined || !folded.has(quoted)) return match
+      const mark = match[0]
+      return `${mark}${quoted.toUpperCase()}${mark}`
+    },
+  )
 }
 
-/** `folded` carries the folded definition when the file was normalised here; no
- * `schema` at all means the file parsed to zero tables — no schema, not an error
- * (the engine would refuse an empty definition outright). An unreadable or
- * malformed file still throws. */
-function loadSchemaFile(schemaPath: string): { schema?: Schema; folded?: { tables: Record<string, any> } } {
+/** `original` and `folded` carry the normalised definition, as written and as stored,
+ * when the file was normalised here; no `schema` at all means the
+ * file parsed to zero tables — no schema, not an error (the engine would refuse an
+ * empty definition outright). An unreadable or malformed file still throws. */
+function loadSchemaFile(schemaPath: string): {
+  schema?: Schema
+  original?: { tables: Record<string, any> }
+  folded?: { tables: Record<string, any> }
+} {
   const ext = path.extname(schemaPath).toLowerCase()
   if (ext === ".json" || ext === ".yaml" || ext === ".yml") {
     const text = fs.readFileSync(schemaPath, "utf8")
     const parsed = ext === ".json" ? JSON.parse(text) : YAML.parse(text)
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      const folded = normalizedSchemaDefinition(parsed, { fold: true })
-      if (Object.keys(folded.tables).length === 0) return {}
-      return { schema: Schema.fromJson(JSON.stringify(folded)), folded }
+      const original = normalizedSchemaDefinition(parsed)
+      if (Object.keys(original.tables).length === 0) return {}
+      const folded = foldSchemaCase(original)
+      return { schema: Schema.fromJson(JSON.stringify(folded)), original, folded }
     }
   }
   return { schema: Schema.fromFile(schemaPath) }