fix(db): read defaultAssistant from config in createCodebase (fixes #1703)

createCodebase() hardcoded 'claude' as the fallback when ai_assistant_type
was not provided, ignoring the user's configured defaultAssistant in
~/.archon/config.yaml.

Now reads the configured default via loadConfig(). Falls back to 'claude'
only if config loading fails.

Author: kagura-agent

packages/core/src/db/codebases.test.ts

@@ -3,6 +3,9 @@ import { createQueryResult, mockPostgresDialect } from '../test/mocks/database';
 import { Codebase } from '../types';
 
 const mockQuery = mock(() => Promise.resolve(createQueryResult([])));
+const mockLoadConfig = mock(() =>
+  Promise.resolve({ assistant: 'claude' } as { assistant: string })
+);
 
 // Mock the connection module before importing the module under test
 mock.module('./connection', () => ({
@@ -12,6 +15,10 @@ mock.module('./connection', () => ({
   getDialect: () => mockPostgresDialect,
 }));
 
+mock.module('../config/config-loader', () => ({
+  loadConfig: mockLoadConfig,
+}));
+
 import {
   createCodebase,
   getCodebase,
@@ -28,6 +35,8 @@ import {
 describe('codebases', () => {
   beforeEach(() => {
     mockQuery.mockClear();
+    mockLoadConfig.mockClear();
+    mockLoadConfig.mockResolvedValue({ assistant: 'claude' } as { assistant: string });
   });
 
   const mockCodebase: Codebase = {
@@ -78,7 +87,23 @@ describe('codebases', () => {
       );
     });
 
-    test('defaults ai_assistant_type to claude', async () => {
+    test('reads defaultAssistant from config when ai_assistant_type omitted', async () => {
+      mockLoadConfig.mockResolvedValueOnce({ assistant: 'codex' } as { assistant: string });
+      mockQuery.mockResolvedValueOnce(
+        createQueryResult([{ ...mockCodebase, ai_assistant_type: 'codex' }])
+      );
+
+      await createCodebase({
+        name: 'test-project',
+        default_cwd: '/workspace/test-project',
+      });
+
+      expect(mockLoadConfig).toHaveBeenCalled();
+      expect(mockQuery).toHaveBeenCalledWith(expect.any(String), expect.arrayContaining(['codex']));
+    });
+
+    test('falls back to claude when config loading fails', async () => {
+      mockLoadConfig.mockRejectedValueOnce(new Error('config not found'));
       mockQuery.mockResolvedValueOnce(createQueryResult([mockCodebase]));
 
       await createCodebase({
@@ -91,6 +116,21 @@ describe('codebases', () => {
         expect.arrayContaining(['claude'])
       );
     });
+
+    test('uses explicit ai_assistant_type over config default', async () => {
+      mockQuery.mockResolvedValueOnce(
+        createQueryResult([{ ...mockCodebase, ai_assistant_type: 'pi' }])
+      );
+
+      await createCodebase({
+        name: 'test-project',
+        default_cwd: '/workspace/test-project',
+        ai_assistant_type: 'pi',
+      });
+
+      expect(mockLoadConfig).not.toHaveBeenCalled();
+      expect(mockQuery).toHaveBeenCalledWith(expect.any(String), expect.arrayContaining(['pi']));
+    });
   });
 
   describe('getCodebase', () => {

packages/core/src/db/codebases.ts

@@ -4,6 +4,7 @@
 import { pool, getDialect } from './connection';
 import type { Codebase } from '../types';
 import { createLogger } from '@archon/paths';
+import { loadConfig } from '../config/config-loader';
 
 /** Lazy-initialized logger (deferred so test mocks can intercept createLogger) */
 let cachedLog: ReturnType<typeof createLogger> | undefined;
@@ -18,7 +19,15 @@ export async function createCodebase(data: {
   default_cwd: string;
   ai_assistant_type?: string;
 }): Promise<Codebase> {
-  const assistantType = data.ai_assistant_type ?? 'claude';
+  let assistantType = data.ai_assistant_type;
+  if (!assistantType) {
+    try {
+      const config = await loadConfig();
+      assistantType = config.assistant;
+    } catch {
+      assistantType = 'claude';
+    }
+  }
   const result = await pool.query<Codebase>(
     'INSERT INTO remote_agent_codebases (name, repository_url, default_cwd, ai_assistant_type) VALUES ($1, $2, $3, $4) RETURNING *',
     [data.name, data.repository_url ?? null, data.default_cwd, assistantType]