fix(docs): agent/schema.md read a DESC index as ascending

`agent/schema.md`'s stated job is "the physical shape of the `postgres` database
… read it before writing a query, a migration, or anything that names a table or
a column". It rendered a live `btree (ts DESC)` recency index as

    - `wake_events_ts_idx` · index · on `ts`

The ordering IS the index for that shape: a reader deciding whether an existing
index serves their ORDER BY got the opposite answer.

`@where`, `@expr` and `@using` were all already rendered on the neighbouring
clause — the estate report guessed `@using` was dropped too and it is not. The one
member of the set missing was `orders`, and not from the renderer: the
`SchemaIndexLike` input type never carried the field, so the direction never
reached the page at all. migrate-ts's own descriptor has had it throughout.

Rendered PER COLUMN rather than per index, because `(device_id ASC, ts DESC)` is a
different index from `(device_id, ts)` and the per-column answer is the one a
reader needs. An all-ascending index stays plain — `asc` on every column would be
noise, and the test asserts that too.

codegen-ts 1576 pass, workspace typecheck clean.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NTcEKXTQMYt84fAjuw5A2M

Author: dmealing

server/typescript/packages/codegen-ts/src/generators/agent-schema-input.ts

@@ -37,6 +37,17 @@ export interface SchemaIndexLike {
   readonly where?: string | undefined;
   readonly expr?: string | undefined;
   readonly using?: string | undefined;
+  /**
+   * Per-column direction, positionally aligned with `columns`. Absent ⇒ all ascending.
+   *
+   * This field did not exist, so `agent/schema.md` rendered a `btree (ts DESC)` recency
+   * index as "on `ts`" — reading as ascending on the page whose stated job is "the physical
+   * shape of the database … read it before writing a query, a migration, or anything that
+   * names a table or a column". The ordering IS the index for that shape. `@where`, `@expr`
+   * and `@using` were all already rendered; this was the one member of the set the input
+   * type never carried.
+   */
+  readonly orders?: readonly ("asc" | "desc")[] | undefined;
 }
 
 export interface SchemaFkLike {

server/typescript/packages/codegen-ts/src/generators/agent-schema-page.ts

@@ -81,8 +81,21 @@ function defaultCell(column: SchemaColumnLike): string {
   return `\`${mdCell(column.default.value)}\``;
 }
 
+/**
+ * The key columns, each carrying its direction when it is not the default.
+ *
+ * `desc` is written where it applies rather than only when the whole index is descending: a
+ * mixed `(a ASC, b DESC)` index is a different index from `(a, b)`, and a reader deciding
+ * whether an existing index serves their ORDER BY needs the per-column answer.
+ */
+function keyColumns(ix: SchemaIndexLike): string {
+  return ix.columns
+    .map((c, i) => (ix.orders?.[i] === "desc" ? `\`${c}\` desc` : `\`${c}\``))
+    .join(", ");
+}
+
 function indexLine(ix: SchemaIndexLike): string {
-  const key = ix.expr !== undefined ? `\`${mdCell(ix.expr)}\`` : cols(ix.columns);
+  const key = ix.expr !== undefined ? `\`${mdCell(ix.expr)}\`` : keyColumns(ix);
   const parts = [`\`${ix.name}\``, ix.unique ? "unique" : "index", `on ${key}`];
   if (ix.using !== undefined && ix.using !== "" && ix.using !== "btree") parts.push(`using \`${ix.using}\``);
   if (ix.where !== undefined && ix.where !== "") parts.push(`where \`${mdCell(ix.where)}\``);

server/typescript/packages/codegen-ts/test/agent-docs-surface.test.ts

@@ -269,6 +269,33 @@ describe("agent/schema.md", () => {
     ...over,
   });
 
+  // F76 — a `btree (ts DESC)` recency index rendered as "on `ts`", reading as ascending on the
+  // page whose stated job is "the physical shape of the database … read it before writing a
+  // query, a migration, or anything that names a table or a column". The ordering IS the index
+  // for that shape. `@where`, `@expr` and `@using` were all already rendered; `orders` was the
+  // one member of the set the input type never carried.
+  test("a DESC index says desc — the ordering is not decoration", async () => {
+    const page = renderAgentSchemaPage(input({
+      tables: [{
+        name: "wake_events",
+        columns: [column("id", { identity: "increment" }), column("ts"), column("device_id")],
+        indexes: [
+          { name: "wake_events_ts_idx", columns: ["ts"], unique: false, orders: ["desc"] },
+          { name: "wake_events_device_idx", columns: ["device_id", "ts"], unique: false, orders: ["asc", "desc"] },
+          { name: "wake_events_plain_idx", columns: ["device_id"], unique: false },
+        ],
+        foreignKeys: [], checks: [], primaryKey: ["id"],
+      }],
+    }), { declaredBy: new Map(), viewLineage: new Map(), relationships: [], enums: [] });
+    expect(page).toContain("`ts` desc");
+    // Mixed directions are per-COLUMN: `(device_id ASC, ts DESC)` is a different index from
+    // `(device_id, ts)`, and a reader deciding whether it serves their ORDER BY needs that.
+    expect(page).toContain("`device_id`, `ts` desc");
+    // An all-ascending index stays plain — `asc` everywhere would be noise, not information.
+    expect(page).toMatch(/wake_events_plain_idx.*`device_id`/);
+    expect(page).not.toContain("`device_id` asc");
+  });
+
   test("a composite unique is labelled composite — a bare `unique` here would be false", async () => {
     const composite = input({
       tables: [