@codeyam/codeyam-cli 0.1.0-staging.b8a55ba → 0.1.0-staging.b8b17a5

package/analyzer-template/packages/database/index.ts

@@ -75,6 +75,7 @@ export * from './src/lib/kysely/tables/backgroundJobsTable';
 export * from './src/lib/kysely/tables/branchesTable';
 export * from './src/lib/kysely/tables/commitBranchesTable';
 export * from './src/lib/kysely/tables/commitsTable';
+export * from './src/lib/kysely/tables/editorScenariosTable';
 export * from './src/lib/kysely/tables/entitiesTable';
 export * from './src/lib/kysely/tables/entityBranchesTable';
 export * from './src/lib/kysely/tables/entityStatementsTable';

package/analyzer-template/packages/database/package.json

@@ -13,10 +13,10 @@
   "license": "ISC",
   "dependencies": {
     "@supabase/supabase-js": "2.88.0",
-    "better-sqlite3": "^12.4.1",
+    "better-sqlite3": "^12.6.2",
     "fetch-retry": "^6.0.0",
-    "kysely": "^0.28.5",
-    "pg": "^8.16.3"
+    "kysely": "^0.28.11",
+    "pg": "^8.20.0"
   },
   "jest": {
     "preset": "ts-jest",
@@ -25,7 +25,7 @@
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
     "@types/jest": "^30.0.0",
-    "@types/pg": "^8.15.5",
+    "@types/pg": "^8.18.0",
     "@types/ws": "^8.18.1"
   }
 }

package/analyzer-template/packages/database/src/lib/analysisBranchToDb.ts

@@ -1,6 +1,6 @@
 import { AnalysisBranch } from '~codeyam/types';
 import { DbAnalysisBranch } from './kysely/tableRelations';
-import { randomUUID } from 'crypto';
+const randomUUID = () => crypto.randomUUID();
 import { AnalysisBranchesTable } from './kysely/tables/analysisBranchesTable';
 import { type Insertable } from 'kysely';
 

package/analyzer-template/packages/database/src/lib/analysisToDb.ts

@@ -1,7 +1,7 @@
 import { Analysis } from '~codeyam/types';
 import { type Insertable } from 'kysely';
 import { AnalysesTable } from './kysely/tables/analysesTable';
-import { randomUUID } from 'crypto';
+const randomUUID = () => crypto.randomUUID();
 
 export default function analysisToDb(
   analysis: Analysis,

package/analyzer-template/packages/database/src/lib/branchToDb.ts

@@ -1,7 +1,7 @@
 import { Branch } from '~codeyam/types';
 import { type Insertable } from 'kysely';
 import { BranchesTable } from './kysely/tables/branchesTable';
-import { randomUUID } from 'crypto';
+const randomUUID = () => crypto.randomUUID();
 
 export default function branchToDb(branch: Branch): Insertable<BranchesTable> {
   const { id, projectId, activeAt, contentChangedAt, metadata, ...remaining } =

package/analyzer-template/packages/database/src/lib/commitBranchToDb.ts

@@ -1,6 +1,6 @@
 import { CommitBranch } from '~codeyam/types';
 import { type Insertable } from 'kysely';
-import { randomUUID } from 'crypto';
+const randomUUID = () => crypto.randomUUID();
 import { CommitBranchesTable } from './kysely/tables/commitBranchesTable';
 
 export default function commitBranchToDb(

package/analyzer-template/packages/database/src/lib/commitToDb.ts

@@ -1,7 +1,7 @@
 import { Commit } from '~codeyam/types';
 import { CommitsTable } from './kysely/tables/commitsTable';
 import { type Insertable } from 'kysely';
-import { randomUUID } from 'crypto';
+const randomUUID = () => crypto.randomUUID();
 
 export default function commitToDb(
   commit: Commit,

package/analyzer-template/packages/database/src/lib/fileToDb.ts

@@ -1,7 +1,7 @@
 import { File } from '~codeyam/types';
 import { type Insertable } from 'kysely';
 import { FilesTable } from './kysely/tables/filesTable';
-import { randomUUID } from 'crypto';
+const randomUUID = () => crypto.randomUUID();
 
 export default function fileToDb(file: File): Insertable<FilesTable> {
   return {

package/analyzer-template/packages/database/src/lib/kysely/db.ts

@@ -36,6 +36,10 @@ import {
   createDebugBundlesTable,
   DebugBundlesTable,
 } from './tables/debugReportsTable';
+import {
+  createLabsRequestsTable,
+  LabsRequestsTable,
+} from './tables/labsRequestsTable';
 import { createEntitiesTable, EntitiesTable } from './tables/entitiesTable';
 import {
   createEntityBranchesTable,
@@ -58,6 +62,10 @@ import {
   createScenarioCommentsTable,
   ScenarioCommentsTable,
 } from './tables/scenarioCommentsTable';
+import {
+  createEditorScenariosTable,
+  EditorScenariosTable,
+} from './tables/editorScenariosTable';
 import { createScenariosTable, ScenariosTable } from './tables/scenariosTable';
 import {
   createStatementsTable,
@@ -102,11 +110,13 @@ const databaseSchema = {
   commit_branches: schemaField<CommitBranchesTable>(),
   commits: schemaField<CommitsTable>(),
   debug_reports: schemaField<DebugBundlesTable>(),
+  editor_scenarios: schemaField<EditorScenariosTable>(),
   entities: schemaField<EntitiesTable>(),
   entity_branches: schemaField<EntityBranchesTable>(),
   entity_statements: schemaField<EntityStatementsTable>(),
   files: schemaField<FilesTable>(),
   github_payloads: schemaField<GithubPayloadsTable>(),
+  labs_requests: schemaField<LabsRequestsTable>(),
   github_users: schemaField<GithubUsersTable>(),
   scenario_comments: schemaField<ScenarioCommentsTable>(),
   scenarios: schemaField<ScenariosTable>(),
@@ -205,6 +215,7 @@ export function getSqliteDatabase(sqlitePath?: string) {
     fileMustExist: false,
   });
   sqlite.pragma('journal_mode = WAL');
+  sqlite.pragma('busy_timeout = 5000');
   sqlite.pragma('synchronous = FULL');
 
   // Verify the database has the expected schema
@@ -245,7 +256,14 @@ export function getSqliteDatabase(sqlitePath?: string) {
 export function getPostgreDatabase() {
   const connectionString = getPostgresConnectionString();
   console.log(`CodeYam: Using PostgreSQL database at: ${connectionString}`);
-  const pool = new Pool({ connectionString });
+  const pool = new Pool({
+    connectionString,
+    // Session pooler (required for IPv4) holds real Postgres connections,
+    // so keep this low: 10 ECS tasks × 3 = 30 connections max
+    max: 3,
+    // Release idle connections after 10s to free up pool slots
+    idleTimeoutMillis: 10000,
+  });
   pool.on('error', (err: Error, _client: PoolClient) => {
     console.error('CodeYam: Unexpected error on idle PostgreSQL client', err);
   });
@@ -293,6 +311,7 @@ export async function getDatabaseForTesting(
     // Standard SQLite testing path
     const sqlite = new SQLiteDatabase(dbPath);
     sqlite.pragma('journal_mode = WAL');
+    sqlite.pragma('busy_timeout = 5000');
     sqlite.pragma('synchronous = FULL');
     const kyselyDb = new Kysely<Database>({
       dialect: new SqliteDialect({ database: sqlite }),
@@ -378,12 +397,14 @@ export async function createSqliteSchema(db: Kysely<Database>): Promise<void> {
   await createCommitBranchesTable(db);
   await createCommitsTable(db);
   await createDebugBundlesTable(db);
+  await createEditorScenariosTable(db);
   await createEntitiesTable(db);
   await createEntityBranchesTable(db);
   await createEntityStatementsTable(db);
   await createFilesTable(db);
   await createGithubPayloadsTable(db);
   await createGithubUsersTable(db);
+  await createLabsRequestsTable(db);
   await createScenarioCommentsTable(db);
   await createScenariosTable(db);
   await createStatementsTable(db);

package/analyzer-template/packages/database/src/lib/kysely/tables/commitsTable.ts

@@ -33,6 +33,12 @@ export const CommitsTableColumns = Object.keys(
   commitsSchema,
 ) as (keyof CommitsTable)[];
 
+// Lightweight columns list excluding 'files' (which can be 1MB+ for large commits)
+// Use this for queries where file diff data is not needed
+export const CommitsTableColumnsLite = CommitsTableColumns.filter(
+  (col) => col !== 'files',
+) as Exclude<keyof CommitsTable, 'files'>[];
+
 export async function createCommitsTable(db: Kysely<any>): Promise<void> {
   await db.schema
     .createTable('commits')

package/analyzer-template/packages/database/src/lib/kysely/tables/debugReportsTable.ts

@@ -6,7 +6,7 @@ import { schemaField, defaultNow } from '../schemaHelpers';
 /**
  * Metadata for a debug bundle upload.
  * Note: "bundle" refers to the tarball upload (base + delta).
- * The markdown "debug report" from /debug-codeyam is stored in feedback.debugReport.
+ * The markdown "debug report" from /codeyam-diagnose is stored in feedback.debugReport.
  */
 interface DebugBundleMetadata {
   timestamp: string;
@@ -25,6 +25,22 @@ interface DebugBundleMetadata {
     platform: string;
     arch: string;
   };
+  feedback?: {
+    source: string;
+    issueType?: string;
+    description?: string;
+    email?: string;
+    entitySha?: string;
+    scenarioId?: string;
+    analysisId?: string;
+    currentUrl?: string;
+    recentActivity?: string[];
+    debugReport?: string;
+    entityName?: string;
+    entityType?: string;
+    scenarioName?: string;
+    errorMessage?: string;
+  };
 }
 
 // Table name remains 'debug_reports' in the database for backwards compatibility

package/analyzer-template/packages/database/src/lib/kysely/tables/editorScenariosTable.ts

@@ -0,0 +1,164 @@
+import { Kysely, ColumnDefinitionBuilder } from 'kysely';
+import type { Generated } from 'kysely';
+
+import { schemaField, defaultNow } from '../schemaHelpers';
+
+const editorScenariosSchema = {
+  id: schemaField<Generated<string>>(),
+  project_id: schemaField<string>(),
+  name: schemaField<string>(),
+  description: schemaField<string | null>(),
+  component_name: schemaField<string | null>(),
+  component_path: schemaField<string | null>(),
+  url: schemaField<string | null>(),
+  type: schemaField<string | null>(),
+  screenshot_path: schemaField<string | null>(),
+  viewport_width: schemaField<number | null>(),
+  viewport_height: schemaField<number | null>(),
+  dimensions: schemaField<string | null>(),
+  screenshot_paths: schemaField<string | null>(),
+  page_file_path: schemaField<string | null>(),
+  entity_sha: schemaField<string | null>(),
+  display_name: schemaField<string | null>(),
+  created_at: schemaField<Generated<string>>(),
+  updated_at: schemaField<Generated<string>>(),
+} as const;
+
+export type EditorScenariosTable = {
+  [K in keyof typeof editorScenariosSchema]: (typeof editorScenariosSchema)[K];
+};
+
+export const EditorScenariosTableColumns = Object.keys(
+  editorScenariosSchema,
+) as (keyof EditorScenariosTable)[];
+
+export async function createEditorScenariosTable(
+  db: Kysely<any>,
+): Promise<void> {
+  await db.schema
+    .createTable('editor_scenarios')
+    .addColumn('id', 'uuid', (col: ColumnDefinitionBuilder) => col.primaryKey())
+    .addColumn('project_id', 'uuid', (col: ColumnDefinitionBuilder) =>
+      col.notNull(),
+    )
+    .addColumn('name', 'varchar', (col: ColumnDefinitionBuilder) =>
+      col.notNull(),
+    )
+    .addColumn('description', 'text')
+    .addColumn('component_name', 'varchar')
+    .addColumn('component_path', 'varchar')
+    .addColumn('url', 'varchar')
+    .addColumn('type', 'varchar')
+    .addColumn('screenshot_path', 'varchar')
+    .addColumn('created_at', 'datetime', defaultNow(true))
+    .addColumn('updated_at', 'datetime', defaultNow(true))
+    .ifNotExists()
+    .execute();
+
+  // Add columns to existing tables (ALTER TABLE has no IF NOT EXISTS in SQLite)
+  for (const col of [
+    'component_name',
+    'component_path',
+    'url',
+    'type',
+    'screenshot_path',
+  ] as const) {
+    try {
+      await db.schema
+        .alterTable('editor_scenarios')
+        .addColumn(col, 'varchar')
+        .execute();
+    } catch {
+      // Column already exists — expected for fresh databases
+    }
+  }
+
+  // Integer columns for viewport dimensions
+  for (const col of ['viewport_width', 'viewport_height'] as const) {
+    try {
+      await db.schema
+        .alterTable('editor_scenarios')
+        .addColumn(col, 'integer')
+        .execute();
+    } catch {
+      // Column already exists — expected for fresh databases
+    }
+  }
+
+  // Multi-dimension support: JSON array of dimension names and map of screenshot paths
+  for (const col of ['dimensions', 'screenshot_paths'] as const) {
+    try {
+      await db.schema
+        .alterTable('editor_scenarios')
+        .addColumn(col, 'text')
+        .execute();
+    } catch {
+      // Column already exists — expected for fresh databases
+    }
+  }
+
+  // Route tracking: page file path for application scenarios
+  // Entity association: SHA links scenario to entity, display_name is the human label
+  for (const col of ['page_file_path', 'entity_sha', 'display_name'] as const) {
+    try {
+      await db.schema
+        .alterTable('editor_scenarios')
+        .addColumn(col, 'varchar')
+        .execute();
+    } catch {
+      // Column already exists — expected for fresh databases
+    }
+  }
+
+  // Legacy backfill: migrate old `dimension` column (single string) into `dimensions`
+  // JSON array. Only runs on databases that have the legacy column — new databases
+  // won't have it. Separated from the screenshot_paths backfill below so that
+  // a missing column doesn't skip both migrations.
+  try {
+    const rows = await db
+      .selectFrom('editor_scenarios')
+      .select(['id', 'dimension', 'dimensions'] as any)
+      .execute();
+    for (const row of rows) {
+      const r = row as any;
+      if (r.dimension && !r.dimensions) {
+        await db
+          .updateTable('editor_scenarios')
+          .set({ dimensions: JSON.stringify([r.dimension]) })
+          .where('id', '=', r.id)
+          .execute();
+      }
+    }
+  } catch {
+    // Column doesn't exist (new DB) or other error — skip
+  }
+
+  // Backfill: wrap existing single screenshot_path into screenshot_paths object
+  try {
+    const rows = await db
+      .selectFrom('editor_scenarios')
+      .select(['id', 'screenshot_path', 'screenshot_paths', 'dimensions'])
+      .execute();
+    for (const row of rows) {
+      const r = row as any;
+      if (r.screenshot_path && !r.screenshot_paths) {
+        let dimName = 'Default';
+        try {
+          const dims = r.dimensions ? JSON.parse(r.dimensions) : null;
+          if (Array.isArray(dims) && dims.length > 0) dimName = dims[0];
+        } catch {
+          /* ignore */
+        }
+        await db
+          .updateTable('editor_scenarios')
+          .set({
+            screenshot_paths: JSON.stringify({ [dimName]: r.screenshot_path }),
+          })
+          .where('id', '=', r.id)
+          .execute();
+      }
+    }
+  } catch {
+    // Backfill is best-effort
+  }
+}

package/analyzer-template/packages/database/src/lib/kysely/tables/labsRequestsTable.ts

@@ -0,0 +1,52 @@
+import { Kysely, ColumnDefinitionBuilder } from 'kysely';
+import type { Generated } from 'kysely';
+
+import { schemaField, defaultNow } from '../schemaHelpers';
+
+const labsRequestsSchema = {
+  id: schemaField<Generated<string>>(),
+  project_slug: schemaField<string>(),
+  name: schemaField<string>(),
+  email: schemaField<string>(),
+  org_name: schemaField<string | null>(),
+  org_size: schemaField<string | null>(),
+  project_size: schemaField<string | null>(),
+  tech_stack: schemaField<string | null>(),
+  status: schemaField<string | null>(),
+  unlock_code: schemaField<string | null>(),
+  created_at: schemaField<Generated<string>>(),
+  approved_at: schemaField<string | null>(),
+} as const;
+
+export type LabsRequestsTable = {
+  [K in keyof typeof labsRequestsSchema]: (typeof labsRequestsSchema)[K];
+};
+
+export const LabsRequestsTableColumns = Object.keys(
+  labsRequestsSchema,
+) as (keyof LabsRequestsTable)[];
+
+export async function createLabsRequestsTable(db: Kysely<any>): Promise<void> {
+  await db.schema
+    .createTable('labs_requests')
+    .addColumn('id', 'uuid', (col: ColumnDefinitionBuilder) => col.primaryKey())
+    .addColumn('project_slug', 'varchar', (col: ColumnDefinitionBuilder) =>
+      col.notNull().unique(),
+    )
+    .addColumn('name', 'varchar', (col: ColumnDefinitionBuilder) =>
+      col.notNull(),
+    )
+    .addColumn('email', 'varchar', (col: ColumnDefinitionBuilder) =>
+      col.notNull(),
+    )
+    .addColumn('org_name', 'varchar')
+    .addColumn('org_size', 'varchar')
+    .addColumn('project_size', 'varchar')
+    .addColumn('tech_stack', 'varchar')
+    .addColumn('status', 'varchar')
+    .addColumn('unlock_code', 'varchar')
+    .addColumn('created_at', 'datetime', defaultNow(true))
+    .addColumn('approved_at', 'datetime')
+    .ifNotExists()
+    .execute();
+}

package/analyzer-template/packages/database/src/lib/loadAnalyses.ts

@@ -27,6 +27,7 @@ function buildAnalysesQuery({
   commitIds,
   branchCommitSha,
   limit,
+  excludeMetadata,
 }: LoadAnalysesArgs & {
   ids?: string[];
   fileIds?: string[];
@@ -37,7 +38,32 @@ function buildAnalysesQuery({
   const { jsonObjectFrom, jsonArrayFrom } = getJsonHelper();
 
   // Create CTE for filtering analyses
-  let filteredAnalysisCTE = db.selectFrom('analyses').selectAll('analyses');
+  // When excludeMetadata is true, select specific columns to avoid loading 64MB+ of metadata
+  let filteredAnalysisCTE = excludeMetadata
+    ? db
+        .selectFrom('analyses')
+        .select([
+          'analyses.id',
+          'analyses.project_id',
+          'analyses.file_id',
+          'analyses.commit_id',
+          'analyses.entity_sha',
+          'analyses.entity_name',
+          'analyses.entity_type',
+          'analyses.file_path',
+          'analyses.status',
+          'analyses.created_at',
+          'analyses.updated_at',
+          'analyses.tree_sha',
+          'analyses.analyzed_tree_sha',
+          'analyses.dependency_analyzed_tree_sha',
+          'analyses.previous_analysis_id',
+          'analyses.branch_commit_sha',
+          'analyses.indirect',
+          'analyses.committed_at',
+          'analyses.completed_at',
+        ])
+    : db.selectFrom('analyses').selectAll('analyses');
 
   // Apply filters
   if (projectId) {
@@ -96,6 +122,35 @@ function buildAnalysesQuery({
   }
 
   // Main query with JSON aggregations referencing the CTE
+  // When excludeMetadata is true, skip the entity subquery (saves loading entity metadata again)
+  if (excludeMetadata) {
+    return db
+      .with('filtered_analyses', () => filteredAnalysisCTE)
+      .selectFrom('filtered_analyses')
+      .selectAll('filtered_analyses')
+      .select((eb: ExpressionBuilder<any, any>) => [
+        // Skip entity subquery - not needed for list views and loads 41MB+ of entity metadata
+
+        jsonArrayFrom(
+          eb
+            .selectFrom('scenarios')
+            .select(aliasedTableColumns('scenarios', ScenariosTableColumns))
+            .whereRef('scenarios.analysis_id', '=', 'filtered_analyses.id'),
+        ).as('scenarios'),
+
+        jsonArrayFrom(
+          eb
+            .selectFrom('analysis_branches')
+            .select(['id', 'branch_id'])
+            .whereRef(
+              'analysis_branches.analysis_id',
+              '=',
+              'filtered_analyses.id',
+            ),
+        ).as('analysis_branches'),
+      ]);
+  }
+
   return db
     .with('filtered_analyses', () => filteredAnalysisCTE)
     .selectFrom('filtered_analyses')
@@ -138,6 +193,8 @@ export interface LoadAnalysesArgs {
   entityShas?: string[];
   branchCommitSha?: string;
   limit?: number;
+  /** Exclude large metadata columns for faster list queries */
+  excludeMetadata?: boolean;
 }
 
 export default async function loadAnalyses(

package/analyzer-template/packages/database/src/lib/loadAnalysis.ts

@@ -45,6 +45,7 @@ export default async function loadAnalysis({
   // TODO: Consider refactoring to use CTE + aliasedTableColumns pattern (Pattern 3)
   // like loadMostRecentPreviousAnalysis for more elegant single-query approach
   const db = getDatabase();
+  const startTime = Date.now();
 
   try {
     // Build the main query
@@ -169,6 +170,8 @@ export default async function loadAnalysis({
     });
 
     const analysis = await query.executeTakeFirst();
+    const queryTime = Date.now() - startTime;
+
     if (!analysis) {
       awsLog('CodeYam Error: Analysis not found', null, {
         id,
@@ -188,6 +191,16 @@ export default async function loadAnalysis({
       return null;
     }
 
+    // DEBUG: Log slow queries (when includeCommitAndBranch=true, includes files column which can be 1MB+)
+    if (queryTime > 100 && includeCommitAndBranch) {
+      const commit = (analysis as any).commit;
+      const filesSize = commit?.files ? JSON.stringify(commit.files).length : 0;
+      console.log(
+        `CodeYam DEBUG: [CommitFilesTiming] loadAnalysis took ${queryTime}ms (files: ${Math.round(filesSize / 1024)}KB)`,
+        { id: analysis.id, entityName: analysis.entity_name },
+      );
+    }
+
     return dbToAnalysis(analysis);
   } catch (error) {
     awsLog('CodeYam Error: Database error loading analysis', error, {

package/analyzer-template/packages/database/src/lib/loadBranch.ts

@@ -98,9 +98,10 @@ async function loadCommitsForBranch(branchId: string): Promise<DbCommit[]> {
   const db = getDatabase();
 
   const { jsonArrayFrom } = getJsonHelper();
+  const startTime = Date.now();
 
   try {
-    return await db
+    const commits = await db
       .selectFrom('commits')
       .selectAll()
       .select((eb: ExpressionBuilder<any, any>) => [
@@ -115,6 +116,20 @@ async function loadCommitsForBranch(branchId: string): Promise<DbCommit[]> {
       .where('commits.branch_id', '=', branchId)
       .orderBy('commits.committed_at', 'desc')
       .execute();
+    const queryTime = Date.now() - startTime;
+
+    // DEBUG: Log slow queries (includes files column which can be 1MB+)
+    if (queryTime > 100) {
+      const totalFilesSize = commits.reduce((sum, c: any) => {
+        return sum + (c.files ? JSON.stringify(c.files).length : 0);
+      }, 0);
+      console.log(
+        `CodeYam DEBUG: [CommitFilesTiming] loadCommitsForBranch took ${queryTime}ms (${commits.length} commits, totalFiles: ${Math.round(totalFilesSize / 1024)}KB)`,
+        { branchId },
+      );
+    }
+
+    return commits;
   } catch (error) {
     awsLog('CodeYam Error: Loading commits for branch', error, { branchId });
     return [];

package/analyzer-template/packages/database/src/lib/loadCommit.ts

@@ -69,6 +69,7 @@ export default async function loadCommit({
   branchId,
 }: LoadCommitArgs) {
   const db = getDatabase();
+  const startTime = Date.now();
 
   try {
     let query = db
@@ -97,6 +98,7 @@ export default async function loadCommit({
     query = query.orderBy('committed_at', 'desc').limit(1);
 
     const commit = await query.executeTakeFirst();
+    const queryTime = Date.now() - startTime;
 
     if (!commit) {
       awsLog('CodeYam Error: Commit not found', null, {
@@ -108,6 +110,15 @@ export default async function loadCommit({
       return null;
     }
 
+    // DEBUG: Log slow queries (includes files column which can be 1MB+)
+    if (queryTime > 100) {
+      const filesSize = commit.files ? JSON.stringify(commit.files).length : 0;
+      console.log(
+        `CodeYam DEBUG: [CommitFilesTiming] loadCommit took ${queryTime}ms (files: ${Math.round(filesSize / 1024)}KB)`,
+        { sha: commit.sha },
+      );
+    }
+
     // Load branch and mergedBranch separately
     const [branch, mergedBranch, analyses] = await Promise.all([
       commit.branch_id