@hyperdrive.bot/gut 0.1.10 → 0.1.12

package/dist/commands/ticket/sync.js

@@ -6,16 +6,24 @@ import { TicketService } from '../../services/ticket.service.js';
 export default class TicketSync extends BaseCommand {
     static args = {
         ticketId: Args.string({
-            description: 'ticket ID to sync',
+            description: 'ticket ID to sync (e.g., PROJ-1234)',
             name: 'ticketId',
             required: true
         })
     };
-    static description = 'Sync ticket state with external source (JIRA, GitHub, etc.)';
+    static description = `Sync ticket state with external source (JIRA, GitHub, etc.)
+
+For pull direction:
+  - If ticket exists in gut: updates from source
+  - If ticket doesn't exist: creates it and queues enrichment
+
+For push direction:
+  - Updates source system with gut ticket state`;
     static examples = [
         '<%= config.bin %> <%= command.id %> PROJ-1234',
         '<%= config.bin %> <%= command.id %> PROJ-1234 --direction push',
-        '<%= config.bin %> <%= command.id %> PROJ-1234 --direction pull'
+        '<%= config.bin %> <%= command.id %> PROJ-1234 --direction pull',
+        '<%= config.bin %> <%= command.id %> PROJ-1234 --direction pull --no-enrich'
     ];
     static flags = {
         direction: Flags.string({
@@ -27,6 +35,10 @@ export default class TicketSync extends BaseCommand {
         json: Flags.boolean({
             char: 'j',
             description: 'output as JSON'
+        }),
+        'no-enrich': Flags.boolean({
+            default: false,
+            description: 'skip enrichment queue when pulling new tickets'
         })
     };
     get requiresInit() {
@@ -39,34 +51,60 @@ export default class TicketSync extends BaseCommand {
             this.error('API not configured. Set GUT_API_ENDPOINT and GUT_TENANT_ID environment variables.');
         }
         const direction = flags.direction;
+        const noEnrich = flags['no-enrich'];
         const directionEmoji = direction === 'push' ? '⬆️' : '⬇️';
         const directionText = direction === 'push'
             ? 'gut → source'
             : 'source → gut';
         const spinner = ora(`${directionEmoji} Syncing ticket (${directionText})...`).start();
         try {
-            const response = await ticketService.syncTicket(args.ticketId, direction);
+            const response = await ticketService.syncTicket(args.ticketId, direction, { noEnrich });
             if (flags.json) {
                 spinner.stop();
                 this.log(JSON.stringify(response, null, 2));
                 return;
             }
-            if (response.synced) {
+            // Different success messages based on what happened
+            if (response.created) {
+                spinner.succeed(chalk.green('Created new ticket from source'));
+            }
+            else if (response.synced) {
                 spinner.succeed('Sync completed');
             }
             else {
                 spinner.warn('Sync completed with warnings');
             }
             this.log('');
-            this.log(chalk.bold(`📋 Ticket: ${response.ticketId}`));
+            // Show ticket info with create/update indicator
+            const statusIcon = response.created ? chalk.green('🆕') : chalk.blue('🔄');
+            this.log(chalk.bold(`${statusIcon} Ticket: ${response.ticketId}`));
             this.log(`   🔗 Source: ${response.source.type}`);
             this.log(`   🌐 URL: ${response.source.externalUrl}`);
+            // Show enrichment status for pull operations
+            if (direction === 'pull') {
+                if (response.enrichmentQueued) {
+                    this.log(`   🔍 Enrichment: ${chalk.cyan('Queued')}`);
+                }
+                else if (response.created && noEnrich) {
+                    this.log(`   🔍 Enrichment: ${chalk.yellow('Skipped (--no-enrich)')}`);
+                }
+            }
             if (response.actions.length > 0) {
                 this.log('');
                 this.log(chalk.bold('📝 Actions performed:'));
                 for (const action of response.actions) {
                     const isError = action.toLowerCase().includes('error');
-                    const icon = isError ? chalk.red('✗') : chalk.green('✓');
+                    const isWarning = action.includes('⚠️');
+                    let icon;
+                    if (isError) {
+                        icon = chalk.red('✗');
+                    }
+                    else if (isWarning) {
+                        icon = chalk.yellow('!');
+                    }
+                    else {
+                        icon = chalk.green('✓');
+                    }
                     this.log(`   ${icon} ${action}`);
                 }
             }
@@ -75,11 +113,27 @@ export default class TicketSync extends BaseCommand {
                 this.log(chalk.dim('   No actions performed'));
             }
             this.log('');
+            // Show next steps for new tickets
+            if (response.created && response.enrichmentQueued) {
+                this.log(chalk.dim('💡 Next: Run ') + chalk.cyan(`gut ticket status ${response.ticketId}`) + chalk.dim(' to check enrichment progress'));
+            }
+            else if (response.created && !response.enrichmentQueued) {
+                this.log(chalk.dim('💡 Next: Run ') + chalk.cyan(`gut ticket sync ${response.ticketId} --pull`) + chalk.dim(' to trigger enrichment'));
+            }
         }
         catch (error) {
             spinner.fail('Sync failed');
             const message = error instanceof Error ? error.message : String(error);
-            this.error(`Failed to sync ticket: ${message}`);
+            // Provide helpful error messages
+            if (message.includes('404') && direction === 'push') {
+                this.error(`Ticket not found in gut. Use ${chalk.cyan('--direction pull')} to create from source.`);
+            }
+            else if (message.includes('404') && direction === 'pull') {
+                this.error(`Ticket not found in source system. Check the ticket ID: ${args.ticketId}`);
+            }
+            else {
+                this.error(`Failed to sync ticket: ${message}`);
+            }
         }
     }
 }

package/dist/commands/worktree/create.d.ts

@@ -0,0 +1,15 @@
+import { BaseCommand } from '../../base-command.js';
+export default class WorktreeCreate extends BaseCommand {
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'base-dir': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        from: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        install: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private runPnpmInstall;
+}

package/dist/commands/worktree/create.js

@@ -0,0 +1,138 @@
+import { Args, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { BaseCommand } from '../../base-command.js';
+export default class WorktreeCreate extends BaseCommand {
+    static args = {
+        name: Args.string({ description: 'Branch name for the worktree', required: true }),
+    };
+    static description = 'Create mirrored worktrees for super-repo and focused entities';
+    static examples = [
+        '<%= config.bin %> worktree create workflow/deploy-batch',
+        '<%= config.bin %> worktree create workflow/deploy-batch --from master --install',
+        '<%= config.bin %> worktree create feature/story-42 --base-dir /home/user/worktrees',
+    ];
+    static flags = {
+        'base-dir': Flags.string({ default: '/tmp/gut-worktrees', description: 'Root directory for worktrees' }),
+        from: Flags.string({ description: 'Base branch to create from (defaults to current branch)' }),
+        install: Flags.boolean({ default: false, description: 'Run pnpm install after creation' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorktreeCreate);
+        const workspaceRoot = this.configService.getWorkspaceRoot();
+        const slug = args.name.replace(/\//g, '-');
+        const wtPath = path.join(flags['base-dir'], slug);
+        const baseBranch = flags.from ?? await this.gitService.getCurrentBranch(workspaceRoot);
+        // --- Validation (AC: 7) ---
+        const existing = this.worktreeService.get(args.name);
+        if (existing) {
+            this.error(`Worktree "${args.name}" already exists at ${existing.path}. Remove it first with: gut worktree remove ${args.name}`);
+        }
+        const existingWorktrees = await this.gitService.worktreeList(workspaceRoot);
+        const branchCollision = existingWorktrees.find(w => w.branch === args.name);
+        if (branchCollision) {
+            this.error(`Branch "${args.name}" already has a worktree at ${branchCollision.path}. Remove it first or use a different name.`);
+        }
+        // --- Validation (AC: 8) ---
+        const focusedEntities = await this.focusService.getFocusedEntities();
+        if (focusedEntities.length === 0) {
+            this.error('No entities focused. Use "gut focus <entity>" first.');
+        }
+        // --- Create worktrees with atomic rollback (AC: 1, 2, 9) ---
+        const createdWorktrees = [];
+        const entityRecords = [];
+        try {
+            // Super-repo worktree (AC: 1)
+            await this.gitService.worktreeAdd(workspaceRoot, wtPath, args.name, baseBranch);
+            createdWorktrees.push({ repoPath: workspaceRoot, wtPath });
+            this.log(chalk.green('✓ Super-repo worktree created at ' + wtPath));
+            // Per-entity worktrees (AC: 2)
+            for (const entity of focusedEntities) {
+                const entityRelativePath = entity.path.replace(/^\.\//, '');
+                const entityWtPath = path.join(wtPath, entityRelativePath);
+                const entityMainPath = path.join(workspaceRoot, entityRelativePath);
+                // Always use the entity's current branch as base — the super-repo branch
+                // may exist but be stale (e.g., api has master but works on develop)
+                const entityBaseBranch = await this.gitService.getCurrentBranch(entityMainPath);
+                if (entityBaseBranch !== baseBranch) {
+                    this.log(chalk.yellow(`⚠ Entity "${entity.name}" is on "${entityBaseBranch}" (super-repo: "${baseBranch}")`));
+                }
+                // Remove submodule stub
+                fs.rmSync(entityWtPath, { force: true, recursive: true });
+                // Create entity worktree
+                await this.gitService.worktreeAdd(entityMainPath, entityWtPath, args.name, entityBaseBranch);
+                createdWorktrees.push({ repoPath: entityMainPath, wtPath: entityWtPath });
+                this.log(chalk.green(`✓ Entity worktree: ${entity.name} → ${args.name}`));
+                entityRecords.push({
+                    branch: args.name,
+                    entityName: entity.name,
+                    entityPath: entityRelativePath,
+                    worktreePath: entityWtPath,
+                });
+            }
+        }
+        catch (error) {
+            // Atomic rollback (AC: 9)
+            for (const entry of [...createdWorktrees].reverse()) {
+                await this.gitService.worktreeRemove(entry.repoPath, entry.wtPath, true).catch(() => { });
+            }
+            await this.gitService.worktreePrune(workspaceRoot).catch(() => { });
+            for (const entity of focusedEntities) {
+                const entityRelativePath = entity.path.replace(/^\.\//, '');
+                const entityMainPath = path.join(workspaceRoot, entityRelativePath);
+                await this.gitService.worktreePrune(entityMainPath).catch(() => { });
+            }
+            this.log(chalk.red('✗ Worktree creation failed. All partial worktrees cleaned up.'));
+            const message = error instanceof Error ? error.message : String(error);
+            this.error(message);
+        }
+        // --- pnpm install (AC: 4) ---
+        if (flags.install) {
+            const startTime = Date.now();
+            try {
+                await this.runPnpmInstall(wtPath);
+                const seconds = Math.round((Date.now() - startTime) / 1000);
+                this.log(chalk.green(`✓ Dependencies installed (pnpm install: ${seconds}s)`));
+            }
+            catch {
+                this.log(chalk.yellow('⚠ pnpm install failed — worktree is still usable without dependencies'));
+            }
+        }
+        // --- Save state (AC: 10) ---
+        const record = {
+            baseBranch,
+            createdAt: Date.now(),
+            entities: entityRecords,
+            name: args.name,
+            path: wtPath,
+        };
+        const state = this.worktreeService.loadState();
+        state.worktrees.push(record);
+        this.worktreeService.saveState(state);
+        // --- Summary output (AC: 11) ---
+        this.log('');
+        this.log('Worktree ready:');
+        this.log(`  Path:   ${wtPath}`);
+        this.log(`  Branch: ${args.name}`);
+        this.log(`  Entities: ${entityRecords.map(e => e.entityName).join(', ')}`);
+        this.log('');
+        this.log('Use with bmad-workflow:');
+        this.log(`  bmad-workflow workflow <prd> --cwd ${wtPath}`);
+    }
+    runPnpmInstall(cwd) {
+        return new Promise((resolve, reject) => {
+            const child = spawn('pnpm', ['install'], { cwd, stdio: 'inherit' });
+            child.on('close', (code) => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`pnpm install exited with code ${code}`));
+                }
+            });
+            child.on('error', reject);
+        });
+    }
+}

package/dist/models/entity.model.d.ts

@@ -232,3 +232,19 @@ export interface RepoStatus {
     path: string;
     untracked: string[];
 }
+export interface WorktreeEntityRecord {
+    branch: string;
+    entityName: string;
+    entityPath: string;
+    worktreePath: string;
+}
+export interface WorktreeRecord {
+    baseBranch: string;
+    createdAt: number;
+    entities: WorktreeEntityRecord[];
+    name: string;
+    path: string;
+}
+export interface WorktreeState {
+    worktrees: WorktreeRecord[];
+}

package/dist/models/ticket.model.d.ts

@@ -86,11 +86,13 @@ export interface HintResponse {
 export interface SyncResponse {
     ticketId: string;
     synced: boolean;
+    created: boolean;
     source: {
         type: string;
         externalUrl: string;
     };
     actions: string[];
+    enrichmentQueued: boolean;
 }
 /**
  * List tickets response from the API

package/dist/services/git.service.d.ts

@@ -17,6 +17,11 @@ export interface PullOptions {
     rebase?: boolean;
     strategy?: string;
 }
+export interface WorktreeInfo {
+    branch: string | null;
+    head: string;
+    path: string;
+}
 export declare class GitService {
     add(repoPath: string, files: string[]): Promise<void>;
     addRemote(repoPath: string, name: string, url: string): Promise<void>;
@@ -28,6 +33,7 @@ export declare class GitService {
     execSync(args: string[], options?: GitOptions): string;
     fetch(repoPath: string): Promise<void>;
     getCurrentBranch(repoPath: string): Promise<string>;
+    branchExists(repoPath: string, branch: string): Promise<boolean>;
     getRemoteUrl(repoPath: string, remote?: string): Promise<null | string>;
     getStatus(repoPath: string): Promise<RepoStatus>;
     hasChanges(repoPath: string): Promise<boolean>;
@@ -36,4 +42,9 @@ export declare class GitService {
     isRepository(repoPath: string): Promise<boolean>;
     pull(repoPath: string, options?: PullOptions): Promise<void>;
     push(repoPath: string, options?: PushOptions): Promise<void>;
+    worktreeAdd(repoPath: string, worktreePath: string, branch: string, baseBranch?: string): Promise<void>;
+    worktreeList(repoPath: string): Promise<WorktreeInfo[]>;
+    worktreePrune(repoPath: string): Promise<void>;
+    worktreeRemove(repoPath: string, worktreePath: string, force?: boolean): Promise<void>;
+    private parseWorktreeList;
 }

package/dist/services/git.service.js

@@ -85,6 +85,15 @@ export class GitService {
         const branch = await this.exec(['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: repoPath });
         return branch.trim();
     }
+    async branchExists(repoPath, branch) {
+        try {
+            await this.exec(['rev-parse', '--verify', `refs/heads/${branch}`], { cwd: repoPath });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     async getRemoteUrl(repoPath, remote = 'origin') {
         try {
             const url = await this.exec(['remote', 'get-url', remote], { cwd: repoPath });
@@ -185,4 +194,52 @@ export class GitService {
         }
         await this.exec(args, { cwd: repoPath });
     }
+    async worktreeAdd(repoPath, worktreePath, branch, baseBranch) {
+        const args = ['worktree', 'add', worktreePath, '-b', branch];
+        if (baseBranch) {
+            args.push(baseBranch);
+        }
+        await this.exec(args, { cwd: repoPath });
+    }
+    async worktreeList(repoPath) {
+        const output = await this.exec(['worktree', 'list', '--porcelain'], { cwd: repoPath });
+        return this.parseWorktreeList(output);
+    }
+    async worktreePrune(repoPath) {
+        await this.exec(['worktree', 'prune'], { cwd: repoPath });
+    }
+    async worktreeRemove(repoPath, worktreePath, force = false) {
+        const args = ['worktree', 'remove', worktreePath];
+        if (force) {
+            args.push('--force');
+        }
+        await this.exec(args, { cwd: repoPath });
+    }
+    parseWorktreeList(output) {
+        if (!output.trim()) {
+            return [];
+        }
+        const blocks = output.trim().split('\n\n');
+        return blocks.filter(block => block.trim()).map(block => {
+            const lines = block.trim().split('\n');
+            let worktreePath = '';
+            let head = '';
+            let branch = null;
+            for (const line of lines) {
+                if (line.startsWith('worktree ')) {
+                    worktreePath = line.slice('worktree '.length);
+                }
+                else if (line.startsWith('HEAD ')) {
+                    head = line.slice('HEAD '.length);
+                }
+                else if (line.startsWith('branch ')) {
+                    branch = line.slice('branch refs/heads/'.length);
+                }
+                else if (line === 'detached') {
+                    branch = null;
+                }
+            }
+            return { branch, head, path: worktreePath };
+        });
+    }
 }

package/dist/services/git.service.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/git.service.test.js

@@ -0,0 +1,101 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { GitService } from './git.service.js';
+describe('GitService worktree methods', () => {
+    let gitService;
+    let execSpy;
+    beforeEach(() => {
+        gitService = new GitService();
+        execSpy = vi.spyOn(gitService, 'exec').mockResolvedValue('');
+    });
+    describe('worktreeAdd', () => {
+        it('calls exec with correct args', async () => {
+            await gitService.worktreeAdd('/repo', '/tmp/wt', 'feat/x');
+            expect(execSpy).toHaveBeenCalledWith(['worktree', 'add', '/tmp/wt', '-b', 'feat/x'], { cwd: '/repo' });
+        });
+        it('includes baseBranch when provided', async () => {
+            await gitService.worktreeAdd('/repo', '/tmp/wt', 'feat/x', 'main');
+            expect(execSpy).toHaveBeenCalledWith(['worktree', 'add', '/tmp/wt', '-b', 'feat/x', 'main'], { cwd: '/repo' });
+        });
+        it('rejects when git exits non-zero', async () => {
+            execSpy.mockRejectedValue(new Error('Git command failed: fatal: branch already exists'));
+            await expect(gitService.worktreeAdd('/repo', '/tmp/wt', 'feat/x'))
+                .rejects.toThrow('Git command failed');
+        });
+    });
+    describe('worktreeList', () => {
+        it('parses multi-entry porcelain output', async () => {
+            const porcelainOutput = [
+                'worktree /path/to/main',
+                'HEAD abc123def456',
+                'branch refs/heads/main',
+                '',
+                'worktree /tmp/gut-worktrees/feat-x',
+                'HEAD def789abc012',
+                'branch refs/heads/feat/x',
+                '',
+            ].join('\n');
+            execSpy.mockResolvedValue(porcelainOutput);
+            const result = await gitService.worktreeList('/repo');
+            expect(result).toEqual([
+                { path: '/path/to/main', head: 'abc123def456', branch: 'main' },
+                { path: '/tmp/gut-worktrees/feat-x', head: 'def789abc012', branch: 'feat/x' },
+            ]);
+            expect(execSpy).toHaveBeenCalledWith(['worktree', 'list', '--porcelain'], { cwd: '/repo' });
+        });
+        it('returns empty array for empty output', async () => {
+            execSpy.mockResolvedValue('');
+            const result = await gitService.worktreeList('/repo');
+            expect(result).toEqual([]);
+        });
+        it('handles detached HEAD entry', async () => {
+            const porcelainOutput = [
+                'worktree /path/to/main',
+                'HEAD abc123',
+                'branch refs/heads/main',
+                '',
+                'worktree /tmp/detached',
+                'HEAD 111222333',
+                'detached',
+                '',
+            ].join('\n');
+            execSpy.mockResolvedValue(porcelainOutput);
+            const result = await gitService.worktreeList('/repo');
+            expect(result).toHaveLength(2);
+            expect(result[0].branch).toBe('main');
+            expect(result[1].branch).toBeNull();
+            expect(result[1].path).toBe('/tmp/detached');
+            expect(result[1].head).toBe('111222333');
+        });
+        it('rejects when git exits non-zero', async () => {
+            execSpy.mockRejectedValue(new Error('Git command failed: not a git repository'));
+            await expect(gitService.worktreeList('/repo'))
+                .rejects.toThrow('Git command failed');
+        });
+    });
+    describe('worktreeRemove', () => {
+        it('calls exec with correct args', async () => {
+            await gitService.worktreeRemove('/repo', '/tmp/wt');
+            expect(execSpy).toHaveBeenCalledWith(['worktree', 'remove', '/tmp/wt'], { cwd: '/repo' });
+        });
+        it('appends --force when force is true', async () => {
+            await gitService.worktreeRemove('/repo', '/tmp/wt', true);
+            expect(execSpy).toHaveBeenCalledWith(['worktree', 'remove', '/tmp/wt', '--force'], { cwd: '/repo' });
+        });
+        it('rejects when git exits non-zero', async () => {
+            execSpy.mockRejectedValue(new Error('Git command failed: not a valid worktree'));
+            await expect(gitService.worktreeRemove('/repo', '/tmp/wt'))
+                .rejects.toThrow('Git command failed');
+        });
+    });
+    describe('worktreePrune', () => {
+        it('calls exec with correct args', async () => {
+            await gitService.worktreePrune('/repo');
+            expect(execSpy).toHaveBeenCalledWith(['worktree', 'prune'], { cwd: '/repo' });
+        });
+        it('rejects when git exits non-zero', async () => {
+            execSpy.mockRejectedValue(new Error('Git command failed: error'));
+            await expect(gitService.worktreePrune('/repo'))
+                .rejects.toThrow('Git command failed');
+        });
+    });
+});

package/dist/services/gut-api.service.d.ts

@@ -41,13 +41,32 @@ export declare class GutApiService extends SigV4ApiClient {
     /**
      * Sync ticket with external source
      */
-    syncTicket(ticketId: string, direction?: 'pull' | 'push'): Promise<SyncResponse>;
+    syncTicket(ticketId: string, direction?: 'pull' | 'push', options?: {
+        noEnrich?: boolean;
+    }): Promise<SyncResponse>;
     /**
      * Update a ticket
      */
     updateTicket(ticketId: string, updates: UpdateTicketRequest): Promise<GutTicket>;
+    /**
+     * Get tenant source configuration
+     */
+    getSourceConfig(): Promise<SourceConfig | null>;
+    /**
+     * Save tenant source configuration
+     */
+    saveSourceConfig(config: SourceConfig): Promise<SourceConfig>;
     /**
      * Test API connection
      */
     testConnection(): Promise<Record<string, unknown>>;
 }
+export interface SourceConfig {
+    type: string;
+    baseUrl: string;
+    credentials: {
+        secretArn: string;
+    };
+    projectMapping?: Record<string, string>;
+    webhookSecret?: string;
+}

package/dist/services/gut-api.service.js

@@ -81,8 +81,12 @@ export class GutApiService extends SigV4ApiClient {
     /**
      * Sync ticket with external source
      */
-    async syncTicket(ticketId, direction = 'push') {
-        return this.makeSignedRequest('POST', `/gut/tickets/${encodeURIComponent(ticketId)}/sync?direction=${direction}`);
+    async syncTicket(ticketId, direction = 'push', options) {
+        const params = new URLSearchParams({ direction });
+        if (options?.noEnrich) {
+            params.set('noEnrich', 'true');
+        }
+        return this.makeSignedRequest('POST', `/gut/tickets/${encodeURIComponent(ticketId)}/sync?${params.toString()}`);
     }
     /**
      * Update a ticket
@@ -90,6 +94,30 @@ export class GutApiService extends SigV4ApiClient {
     async updateTicket(ticketId, updates) {
         return this.makeSignedRequest('PATCH', `/gut/tickets/${encodeURIComponent(ticketId)}`, updates);
     }
+    // ============================================================================
+    // Config Methods
+    // ============================================================================
+    /**
+     * Get tenant source configuration
+     */
+    async getSourceConfig() {
+        try {
+            return await this.makeSignedRequest('GET', '/gut/config/source');
+        }
+        catch (error) {
+            const err = error;
+            if (err.response?.status === 404) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Save tenant source configuration
+     */
+    async saveSourceConfig(config) {
+        return this.makeSignedRequest('PUT', '/gut/config/source', config);
+    }
     /**
      * Test API connection
      */

package/dist/services/tenant.service.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Gut Tenant Service
+ *
+ * Uses shared TenantService from cli-auth with gut-specific configuration.
+ */
+import { TenantService, type TenantServiceConfig } from '@hyperdrive.bot/cli-auth';
+/**
+ * Gut-specific tenant service configuration
+ */
+export declare const GUT_TENANT_CONFIG: TenantServiceConfig;
+/**
+ * Create a configured TenantService instance for gut
+ */
+export declare function createTenantService(domain?: string): TenantService;

package/dist/services/tenant.service.js

@@ -0,0 +1,24 @@
+/**
+ * Gut Tenant Service
+ *
+ * Uses shared TenantService from cli-auth with gut-specific configuration.
+ */
+import { TenantService } from '@hyperdrive.bot/cli-auth';
+/**
+ * Gut-specific tenant service configuration
+ */
+export const GUT_TENANT_CONFIG = {
+    appName: 'gut',
+    defaultBootstrapUrl: 'https://api.hyperdrive.bot/tenant/bootstrap',
+    bootstrapUrlEnvVar: 'GUT_BOOTSTRAP_URL',
+    tenantDomainEnvVar: 'GUT_TENANT_DOMAIN',
+    apiUrlEnvVar: 'GUT_API_ENDPOINT',
+    primaryApiName: 'gut',
+    additionalApiNames: ['hyperdrive'],
+};
+/**
+ * Create a configured TenantService instance for gut
+ */
+export function createTenantService(domain) {
+    return new TenantService(GUT_TENANT_CONFIG, domain);
+}

package/dist/services/ticket.service.d.ts

@@ -51,7 +51,9 @@ export declare class TicketService {
     /**
      * Sync ticket with external source
      */
-    syncTicket(ticketId: string, direction?: 'pull' | 'push'): Promise<SyncResponse>;
+    syncTicket(ticketId: string, direction?: 'pull' | 'push', options?: {
+        noEnrich?: boolean;
+    }): Promise<SyncResponse>;
     /**
      * Update a ticket
      */