fix(profile): fix alias pattern and schema repair robustness

- Remove trailing \d* from ALIAS_PATTERN since disambiguateSegments
  uses 'x' prefix, not numeric suffix. This prevents misclassifying
  inputs like 'process2' as aliases.
- Separate index creation from table DDL in repairMissingTables so
  a failed index doesn't prevent subsequent repair passes from
  creating it (table exists check was skipping the index).

Author: BYK

src/lib/db/schema.ts

@@ -398,23 +398,43 @@ export type RepairResult = {
   failed: string[];
 };
 
+/** Index for efficient alias lookups by alias string + fingerprint */
+const TRANSACTION_ALIASES_INDEX = `
+  CREATE INDEX IF NOT EXISTS idx_txn_alias_lookup 
+  ON transaction_aliases(alias, fingerprint)
+`;
+
 function repairMissingTables(db: Database, result: RepairResult): void {
   for (const [tableName, ddl] of Object.entries(EXPECTED_TABLES)) {
     if (tableExists(db, tableName)) {
       continue;
     }
     try {
       db.exec(ddl);
-      // Create associated indexes for tables that need them
-      if (tableName === "transaction_aliases") {
-        db.exec(TRANSACTION_ALIASES_INDEX);
-      }
       result.fixed.push(`Created table ${tableName}`);
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
       result.failed.push(`Failed to create table ${tableName}: ${msg}`);
     }
   }
+  // Create indexes for newly created tables (separate pass to avoid
+  // leaving the index uncreated if the table DDL succeeds but the
+  // index fails in the same try/catch)
+  ensureTableIndexes(db, result);
+}
+
+/** Ensure indexes exist for tables that need them */
+function ensureTableIndexes(db: Database, result: RepairResult): void {
+  if (tableExists(db, "transaction_aliases")) {
+    try {
+      db.exec(TRANSACTION_ALIASES_INDEX);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      result.failed.push(
+        `Failed to create index for transaction_aliases: ${msg}`
+      );
+    }
+  }
 }
 
 function repairMissingColumns(db: Database, result: RepairResult): void {
@@ -569,12 +589,6 @@ export function tryRepairAndRetry<T>(
   return { attempted: false };
 }
 
-/** Index for efficient alias lookups by alias string + fingerprint */
-const TRANSACTION_ALIASES_INDEX = `
-  CREATE INDEX IF NOT EXISTS idx_txn_alias_lookup 
-  ON transaction_aliases(alias, fingerprint)
-`;
-
 export function initSchema(db: Database): void {
   const ddlStatements = Object.values(EXPECTED_TABLES).join(";\n\n");
   db.exec(ddlStatements);

src/lib/resolve-transaction.ts

@@ -48,25 +48,25 @@ const MAX_ALIAS_LENGTH = 20;
 
 /**
  * Pattern matching alias-shaped input: purely ASCII letters in a single case
- * (all lowercase or all uppercase for caps-lock tolerance), optionally
- * followed by a numeric disambiguator (e.g. "issues2", "ISSUES2").
+ * (all lowercase or all uppercase for caps-lock tolerance).
  *
  * This mirrors how `buildTransactionAliases` generates aliases:
  * segments are lowercased, stripped of hyphens/underscores, then
- * `findShortestUniquePrefixes` produces a lowercase-letter prefix,
- * and `disambiguateSegments` may append a numeric suffix.
+ * `findShortestUniquePrefixes` produces a lowercase-letter prefix.
+ * `disambiguateSegments` prepends "x" characters for duplicates
+ * (e.g. "xissues", "xxissues"), so aliases are always purely alphabetic.
  *
  * Mixed-case inputs like "ProcessEvent" are treated as full transaction
  * names since aliases are always lowercase (or all-caps with caps lock).
  */
-const ALIAS_PATTERN = /^(?:[a-z]+|[A-Z]+)\d*$/;
+const ALIAS_PATTERN = /^(?:[a-z]+|[A-Z]+)$/;
 
 /**
  * Check if input looks like a cached alias rather than a full transaction name.
  *
- * Aliases are short, single-case letter strings (with optional numeric suffix).
- * Anything containing special characters like `/`, `.`, `-`, `_`, spaces,
- * colons, or mixed-case letters is treated as a full transaction name.
+ * Aliases are short, purely alphabetic, single-case strings.
+ * Anything containing digits, special characters like `/`, `.`, `-`, `_`,
+ * spaces, colons, or mixed-case letters is treated as a full transaction name.
  */
 function isAliasLike(input: string): boolean {
   return input.length <= MAX_ALIAS_LENGTH && ALIAS_PATTERN.test(input);
@@ -147,8 +147,8 @@ function buildUnknownRefError(
  *
  * Resolution order:
  *   1. Numeric index: "1", "2", "10" → looks up by cached index
- *   2. Alias-shaped input (single-case letters + optional digits, ≤20 chars):
- *      "i", "e", "iu", "issues2", "I" (caps lock) → looks up by cached alias
+ *   2. Alias-shaped input (single-case letters only, ≤20 chars):
+ *      "i", "e", "iu", "xissues", "I" (caps lock) → looks up by cached alias
  *   3. Everything else is treated as a full transaction name and passed through:
  *      "/api/0/...", "tasks.process", "process_request", "handle-webhook",
  *      "ProcessEvent", "GET /users"