# Hook Integration Bug Fix - Comprehensive Quality Review
**Date:** 2026-01-01
**Reviewer:** Claude Code
**Bug:** WriteTool.ts line 735 - filename without extension passed to `writeLocalAndValidateHooksOnly`
**Fix:** Changed `filename` to `fullFilename` (with extension)
---
## Executive Summary
✅ **FIX IS CORRECT - But reveals broader architectural issues**
The fix at line 735 is correct and solves the immediate problem where `git add` was failing because files on disk have extensions (e.g., `.html`) but the function was receiving filenames without extensions (e.g., `sheets-sidebar/html/include/SidebarAppInit`).
However, this review reveals:
- ✅ **No other instances of this specific bug** in the codebase
- ⚠️ **Architectural inconsistency** in filename handling across the codebase
- 📋 **Missing test coverage** for hook integration with extensions
- 🔧 **Refactoring opportunity** to eliminate filename/fullFilename confusion
---
## 1. Correctness & Completeness
### ✅ Fix is Correct
**Location:** `/Users/jameswiese/src/mcp_gas/src/tools/filesystem/WriteTool.ts:735`
```typescript
// BEFORE (BUG):
const hookResult = await writeLocalAndValidateHooksOnly(
content,
filePath,
filename, // ❌ WITHOUT extension (e.g., "sheets-sidebar/html/include/SidebarAppInit")
projectPath
);
// AFTER (FIXED):
const hookResult = await writeLocalAndValidateHooksOnly(
content,
filePath,
fullFilename, // ✅ WITH extension (e.g., "sheets-sidebar/html/include/SidebarAppInit.html")
projectPath
);
```
**Why the fix is correct:**
1. **Line 720-721** correctly computes `fullFilename`:
```typescript
const fileExtension = LocalFileManager.getFileExtensionFromName(filename);
const fullFilename = filename + fileExtension; // ✅ Adds extension
```
2. **Line 723** creates `filePath` using `fullFilename`:
```typescript
const filePath = join(projectPath, fullFilename); // ✅ Uses fullFilename
```
3. **hookIntegration.ts:247** performs `git add filename`:
```typescript
const addResult = await runGitCommand(['add', filename], gitRoot);
```
This requires the filename to match the actual file on disk, which has the extension.
4. **Root cause:** Git operations require filenames that match the filesystem (with extensions), but GAS API uses filenames without extensions.
### ✅ No Other Instances of This Bug
**Searched:** All calls to `writeLocalAndValidateHooksOnly`
**Result:** Only ONE call site exists (WriteTool.ts:732)
```bash
# Search results:
src/utils/hookIntegration.ts:220:export async function writeLocalAndValidateHooksOnly(
src/tools/filesystem/WriteTool.ts:10:import { writeLocalAndValidateHooksOnly } from '../../utils/hookIntegration.js';
src/tools/filesystem/WriteTool.ts:732: const hookResult = await writeLocalAndValidateHooksOnly(
```
**Conclusion:** This was the ONLY place where the bug could occur, and it's now fixed.
---
## 2. Consistency Analysis
### ⚠️ Architectural Inconsistency Detected
The codebase has **TWO patterns** for handling filenames, and they're mixed inconsistently:
#### Pattern A: GitOperationManager (CORRECT - uses fullFilename everywhere)
**Location:** `src/core/git/GitOperationManager.ts:211-243`
```typescript
for (const [filename, content] of computedChanges.entries()) {
const fileExtension = LocalFileManager.getFileExtensionFromName(filename);
const fullFilename = filename + fileExtension; // ✅ Compute extension
const filePath = join(localPath, fullFilename); // ✅ Use fullFilename
// ... write/delete operations using fullFilename ...
log.debug(`[GIT-MANAGER] Wrote local file: ${fullFilename}`); // ✅ Log fullFilename
}
// Convert GAS filenames to local filenames with extensions for git
const affectedFilesWithExtensions = affectedFiles.map(filename => {
const fileExtension = LocalFileManager.getFileExtensionFromName(filename);
return filename + fileExtension; // ✅ Add extension for git operations
});
await LocalFileManager.stageChangesOnly(projectPath, affectedFilesWithExtensions); // ✅ Pass with extensions
```
**Key insight:** GitOperationManager ALWAYS adds extensions before any filesystem or git operations.
#### Pattern B: WriteTool (MIXED - sometimes filename, sometimes fullFilename)
**Location:** `src/tools/filesystem/WriteTool.ts`
**Inconsistent usage:**
| Line | Variable | Context | Correct? |
|------|----------|---------|----------|
| 375 | `fullFilename` | Local file path | ✅ |
| 495 | `fullFilename` | Local file path | ✅ |
| 530 | `fullFilename` | Local file path | ✅ |
| 721 | `fullFilename` | Local file path | ✅ |
| 735 | `fullFilename` | Git operation | ✅ (FIXED) |
| 759 | `filename` | Remote GAS lookup | ✅ (GAS uses no extension) |
| 831 | `fullFilename` | Git reset | ✅ |
| 844 | `fullFilename` | Git rm | ✅ |
**Observation:** After the fix, WriteTool now correctly uses:
- `filename` (no extension) for GAS API operations
- `fullFilename` (with extension) for local filesystem and git operations
### ✅ Consistency with Other Tools
**Edit, Aider, Cp, Mv, Rm all use GitOperationManager** - they don't have this issue because GitOperationManager handles extension logic internally.
**Only WriteTool has direct hook integration** - no other tool calls `writeLocalAndValidateHooksOnly`, so this pattern doesn't exist elsewhere.
---
## 3. Edge Cases
### ✅ Edge Case: Files without extensions (e.g., `Code`, `appsscript`)
**Test:** Does `getFileExtensionFromName` handle these correctly?
**Location:** `src/utils/localFileManager.ts:1031-1039`
```typescript
static getFileExtensionFromName(filename: string): string {
if (filename.toLowerCase() === 'appsscript') {
return '.json'; // ✅ Special case
} else if (filename.includes('.')) {
return ''; // ✅ Already has extension
} else {
return '.gs'; // ✅ Default
}
}
```
**Test scenarios:**
| Input | Extension | fullFilename | On Disk |
|-------|-----------|--------------|---------|
| `appsscript` | `.json` | `appsscript.json` | ✅ |
| `Code` | `.gs` | `Code.gs` | ✅ |
| `utils.gs` | `` (empty) | `utils.gs` | ✅ |
| `index.html` | `` (empty) | `index.html` | ✅ |
| `config.test.js` | `` (empty) | `config.test.js` | ✅ |
**Result:** ✅ Edge cases handled correctly
### ✅ Edge Case: Virtual files (`.gitignore.gs` → `.gitignore`)
**Concern:** Virtual file translation might cause issues with git operations.
**Investigation:** Virtual file translation happens BEFORE the hook integration:
```typescript
// Line 343: Virtual file translation applied early
const translatedPath = translatePathForOperation(params.path, true);
const { scriptId, cleanPath: filename } = parsePath(`${resolvedScriptId}/${translatedPath}`);
// Line 720-721: Extension added based on translated filename
const fileExtension = LocalFileManager.getFileExtensionFromName(filename);
const fullFilename = filename + fileExtension;
// Line 735: Hook gets the final filename with extension
await writeLocalAndValidateHooksOnly(content, filePath, fullFilename, projectPath);
```
**Example flow:**
1. User provides: `.gitignore`
2. Virtual translation: `.gitignore.gs` (in GAS)
3. Extension logic: `.gitignore.gs` already has extension → no addition
4. Git operation: `git add .gitignore.gs` ✅
**Result:** ✅ Virtual files work correctly
### ✅ Edge Case: Nested paths with extensions (e.g., `sheets-sidebar/html/include/SidebarAppInit.html`)
**This is the ORIGINAL BUG SCENARIO**
**Before fix:**
```typescript
filename = "sheets-sidebar/html/include/SidebarAppInit" // No extension
git add "sheets-sidebar/html/include/SidebarAppInit" // ❌ File not found
```
**After fix:**
```typescript
filename = "sheets-sidebar/html/include/SidebarAppInit"
fullFilename = "sheets-sidebar/html/include/SidebarAppInit.html" // Added extension
git add "sheets-sidebar/html/include/SidebarAppInit.html" // ✅ File exists
```
**Result:** ✅ Fixed
---
## 4. Test Coverage
### ❌ Missing Test Coverage for Hook Integration
**Search results:** No tests found for `writeLocalAndValidateHooksOnly`
```bash
# Searched for:
test.*writeLocalAndValidateHooksOnly
test.*hook
describe.*hook
```
**Result:** Tests exist for git auto-commit, but NOT specifically for hook integration with different file types.
### 📋 Recommended Tests
**Unit tests for `hookIntegration.ts`:**
```typescript
describe('writeLocalAndValidateHooksOnly', () => {
describe('filename handling', () => {
it('should accept filename with extension (.gs)', async () => {
await writeLocalAndValidateHooksOnly(content, '/path/file.gs', 'file.gs', gitRoot);
// Verify: git add file.gs
});
it('should accept filename with extension (.html)', async () => {
await writeLocalAndValidateHooksOnly(content, '/path/index.html', 'index.html', gitRoot);
// Verify: git add index.html
});
it('should accept nested path with extension', async () => {
const filename = 'sheets-sidebar/html/include/SidebarAppInit.html';
await writeLocalAndValidateHooksOnly(content, `/path/${filename}`, filename, gitRoot);
// Verify: git add sheets-sidebar/html/include/SidebarAppInit.html
});
it('should reject filename without extension', async () => {
// This would be the BUG case - verify it fails correctly
await expect(
writeLocalAndValidateHooksOnly(content, '/path/file', 'file', gitRoot)
).to.eventually.be.rejectedWith(/git add failed/);
});
});
describe('file type variations', () => {
it('should handle SERVER_JS files (.gs)', async () => { /* ... */ });
it('should handle HTML files (.html)', async () => { /* ... */ });
it('should handle JSON files (.json)', async () => { /* ... */ });
it('should handle virtual files (.gitignore.gs)', async () => { /* ... */ });
});
describe('edge cases', () => {
it('should handle appsscript.json', async () => { /* ... */ });
it('should handle files with multiple dots (test.spec.js)', async () => { /* ... */ });
it('should handle files without extension (Code)', async () => { /* ... */ });
});
});
```
**Integration test for WriteTool:**
```typescript
describe('WriteTool hook integration', () => {
it('should write nested HTML file and stage with correct extension', async () => {
const writeTool = new WriteTool();
const result = await writeTool.execute({
scriptId: TEST_SCRIPT_ID,
path: 'sheets-sidebar/html/include/SidebarAppInit',
content: '<html><body>Test</body></html>',
fileType: 'HTML'
});
// Verify: File written with .html extension
// Verify: git add sheets-sidebar/html/include/SidebarAppInit.html succeeded
// Verify: File is staged
});
it('should write .gs file and stage with correct extension', async () => { /* ... */ });
it('should write appsscript.json and stage correctly', async () => { /* ... */ });
});
```
**Regression test for the original bug:**
```typescript
describe('WriteTool regression tests', () => {
it('should not pass filename without extension to hook integration', async () => {
// This test ensures the bug doesn't come back
const spy = sinon.spy(hookIntegration, 'writeLocalAndValidateHooksOnly');
await writeTool.execute({
scriptId: TEST_SCRIPT_ID,
path: 'sheets-sidebar/html/include/SidebarAppInit',
content: '<html></html>',
fileType: 'HTML'
});
// Verify: 3rd argument (filename) has extension
const filenameArg = spy.firstCall.args[2];
expect(filenameArg).to.include('.html');
expect(filenameArg).to.not.equal('sheets-sidebar/html/include/SidebarAppInit');
});
});
```
---
## 5. Documentation
### ✅ Inline Comment is Sufficient
**Location:** `WriteTool.ts:735`
```typescript
fullFilename, // Use full filename with extension for git operations
```
**Assessment:** Comment clearly explains WHY `fullFilename` is used (for git operations).
### 📋 Additional Documentation Needed
**1. Update function JSDoc in `hookIntegration.ts:216`:**
```typescript
/**
* Write content to local file, stage with git, and validate with hooks
*
* IMPORTANT: This function requires the filename to include the extension
* (e.g., "file.html", not "file") because it performs git operations that
* reference files on disk.
*
* @param content - Original content to write
* @param filePath - Full local file path (with extension)
* @param filename - Relative file path within git repo (WITH extension) // ⬅️ ADD THIS
* @param gitRoot - Git repository root path
* @returns HookOnlyValidationResult with success status and final content
*/
export async function writeLocalAndValidateHooksOnly(
content: string,
filePath: string,
filename: string, // Must include extension (e.g., "file.html")
gitRoot: string
): Promise<HookOnlyValidationResult> { /* ... */ }
```
**2. Add architecture note in CLAUDE.md:**
```markdown
### Filename Conventions
**CRITICAL:** The codebase uses two filename formats:
1. **GAS filename** (no extension): Used for GAS API calls
- Example: `"sheets-sidebar/html/include/SidebarAppInit"`
- Used with: `gasClient.getProjectContent()`, `gasClient.updateProjectContent()`
2. **Local filename** (with extension): Used for filesystem and git operations
- Example: `"sheets-sidebar/html/include/SidebarAppInit.html"`
- Used with: `writeFile()`, `readFile()`, `git add`, `git reset`
**Pattern:**
```typescript
const filename = "file"; // GAS format (no extension)
const fileExtension = LocalFileManager.getFileExtensionFromName(filename);
const fullFilename = filename + fileExtension; // Local format (with extension)
// GAS API: use filename
await gasClient.updateProjectContent(scriptId, [{ name: filename, ... }]);
// Local filesystem/git: use fullFilename
await writeFile(join(projectPath, fullFilename), content);
await runGitCommand(['add', fullFilename], projectPath);
```
**See:** GitOperationManager.ts:211-243 for the canonical implementation.
```
---
## 6. Related Code Smells
### ⚠️ Code Smell: filename/fullFilename Confusion
**Problem:** Having both `filename` and `fullFilename` variables in the same function creates cognitive overhead and risk of using the wrong one.
**Evidence:**
```typescript
// WriteTool.ts:720-735
const fileExtension = LocalFileManager.getFileExtensionFromName(filename);
const fullFilename = filename + fileExtension; // ⬅️ Now we have TWO variables
const projectPath = await LocalFileManager.getProjectDirectory(projectName, workingDir);
const filePath = join(projectPath, fullFilename); // ⬅️ Use fullFilename here
// ... 10 lines later ...
const hookResult = await writeLocalAndValidateHooksOnly(
content,
filePath,
fullFilename, // ⬅️ Easy to accidentally use 'filename' instead (BUG!)
projectPath
);
```
**Why this is risky:**
1. Both variables are in scope simultaneously
2. They have similar names (`filename` vs `fullFilename`)
3. No type safety - both are strings
4. Bug was caused by this exact confusion
### 🔧 Refactoring Opportunity: Eliminate fullFilename
**Option 1: Rename variables to be explicit**
```typescript
// BEFORE (confusing):
const filename = "file"; // No extension
const fullFilename = filename + ext; // With extension
// AFTER (clear):
const gasFilename = "file"; // Explicitly for GAS API
const localFilename = "file.html"; // Explicitly for local ops
```
**Option 2: Create a FilePathContext class**
```typescript
class FilePathContext {
constructor(
public readonly gasName: string, // "file"
public readonly extension: string, // ".html"
public readonly projectPath: string // "/path/to/project"
) {}
get localName(): string {
return this.gasName + this.extension; // "file.html"
}
get localPath(): string {
return join(this.projectPath, this.localName); // "/path/to/project/file.html"
}
}
// Usage:
const ctx = new FilePathContext(filename, fileExtension, projectPath);
await writeLocalAndValidateHooksOnly(content, ctx.localPath, ctx.localName, ctx.projectPath);
```
**Option 3: Make hookIntegration accept gasName and compute extension internally**
```typescript
// BEFORE (caller must compute extension):
const fileExtension = LocalFileManager.getFileExtensionFromName(filename);
const fullFilename = filename + fileExtension;
await writeLocalAndValidateHooksOnly(content, filePath, fullFilename, projectPath);
// AFTER (hookIntegration computes extension):
await writeLocalAndValidateHooksOnly(content, filePath, filename, projectPath, { addExtension: true });
// OR
await writeLocalAndValidateHooksOnlyFromGasName(content, projectPath, gasFilename);
```
**Recommendation:** Option 1 (rename variables) is the simplest and safest fix with minimal refactoring.
### ⚠️ Code Smell: Extension Logic Scattered
**Problem:** Extension computation is duplicated across the codebase:
```typescript
// WriteTool.ts:720
const fileExtension = LocalFileManager.getFileExtensionFromName(filename);
const fullFilename = filename + fileExtension;
// GitOperationManager.ts:213
const fileExtension = LocalFileManager.getFileExtensionFromName(filename);
const fullFilename = filename + fileExtension;
// WriteTool.ts:495 (again)
const fileExtension = LocalFileManager.getFileExtensionFromName(filename);
const fullFilename = filename + fileExtension;
// WriteTool.ts:530 (again)
const fileExtension = LocalFileManager.getFileExtensionFromName(filename);
const fullFilename = filename + fileExtension;
```
**Count:** 4+ occurrences of this pattern in WriteTool.ts alone.
**Refactoring suggestion:**
```typescript
// In LocalFileManager:
static getLocalFilename(gasFilename: string): string {
const extension = this.getFileExtensionFromName(gasFilename);
return gasFilename + extension;
}
// Usage (1 line instead of 2):
const localFilename = LocalFileManager.getLocalFilename(filename);
```
### ⚠️ Code Smell: No Type Safety for Filenames
**Problem:** Both `filename` and `fullFilename` are `string` types - TypeScript can't prevent using the wrong one.
**Example of what went wrong:**
```typescript
// Both are strings - no compile-time safety
const filename: string = "file";
const fullFilename: string = "file.html";
// ❌ BUG: TypeScript allows this
await writeLocalAndValidateHooksOnly(content, filePath, filename, projectPath);
// ✅ CORRECT: But TypeScript can't enforce this
await writeLocalAndValidateHooksOnly(content, filePath, fullFilename, projectPath);
```
**Refactoring suggestion: Branded types**
```typescript
type GasFilename = string & { readonly __brand: 'GasFilename' };
type LocalFilename = string & { readonly __brand: 'LocalFilename' };
function createGasFilename(name: string): GasFilename {
return name as GasFilename;
}
function createLocalFilename(gasName: GasFilename, ext: string): LocalFilename {
return (gasName + ext) as LocalFilename;
}
// Function signature:
export async function writeLocalAndValidateHooksOnly(
content: string,
filePath: string,
filename: LocalFilename, // ⬅️ Now TypeScript enforces this
gitRoot: string
): Promise<HookOnlyValidationResult>
// Usage:
const gasName = createGasFilename(filename);
const localName = createLocalFilename(gasName, fileExtension);
await writeLocalAndValidateHooksOnly(content, filePath, localName, projectPath); // ✅ Type safe
await writeLocalAndValidateHooksOnly(content, filePath, gasName, projectPath); // ❌ Compile error
```
**Benefit:** TypeScript would have caught the original bug at compile time.
---
## 7. Security Review
### ✅ No Security Issues
**Command injection prevention:** Already verified in NO_AUTO_COMMIT_QUALITY_REVIEW.md
```typescript
// hookIntegration.ts:247 - Uses spawn with array args
const addResult = await runGitCommand(['add', filename], gitRoot);
// runGitCommand uses spawn internally:
function runGitCommand(args: string[], cwd: string): Promise<GitCommandResult> {
return new Promise((resolve) => {
const git = spawn('git', args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
// ... safe handling ...
});
}
```
**Path traversal prevention:**
```typescript
// filename is validated early in the flow:
const parsedPath = parsePath(fullPath);
if (!parsedPath.isFile || !parsedPath.filename) {
throw new ValidationError('path', params.path, 'file path must include a filename');
}
```
**Result:** ✅ No security issues introduced by the fix
---
## 8. Performance Impact
### ✅ No Performance Impact
**Analysis:**
```typescript
// Line 720-721: Added operations
const fileExtension = LocalFileManager.getFileExtensionFromName(filename); // ~0.1ms (string ops)
const fullFilename = filename + fileExtension; // ~0.01ms (string concat)
```
**Total overhead:** ~0.11ms (negligible)
**Comparison:**
- Git operations: 50-200ms
- Network calls: 100-500ms
- Extension computation: 0.11ms (< 0.1% of total)
**Result:** ✅ No meaningful performance impact
---
## Findings Summary
### ✅ Strengths
1. **Fix is correct** - Solves the immediate problem
2. **No other instances** - This was the only place with the bug
3. **Edge cases handled** - Works with all file types and paths
4. **Security maintained** - No command injection issues
5. **No performance impact** - Negligible overhead
### ❌ Issues Found
**NONE** - The fix is correct and complete.
### ⚠️ Concerns & Risks
1. **Architectural inconsistency** - filename vs fullFilename confusion
2. **Missing test coverage** - No tests for hook integration with extensions
3. **Code duplication** - Extension logic repeated 4+ times
4. **No type safety** - TypeScript can't prevent using wrong filename type
5. **Documentation gaps** - Function JSDoc doesn't mention extension requirement
### 📋 Recommendations
#### High Priority (Do Soon)
1. **Add regression test** (15 minutes)
```typescript
it('should pass fullFilename (with extension) to hook integration', async () => {
// Spy on writeLocalAndValidateHooksOnly
// Verify 3rd argument has extension
});
```
2. **Update JSDoc** (5 minutes)
```typescript
* @param filename - Relative file path within git repo (WITH extension)
```
3. **Rename variables** (30 minutes)
```typescript
const gasFilename = filename; // For GAS API
const localFilename = filename + fileExtension; // For local/git ops
```
#### Medium Priority (Do This Sprint)
4. **Add comprehensive tests** (2 hours)
- Unit tests for hookIntegration with different file types
- Integration tests for WriteTool hook flow
- Edge case tests (nested paths, virtual files, etc.)
5. **Extract extension logic** (1 hour)
```typescript
static getLocalFilename(gasFilename: string): string {
return gasFilename + this.getFileExtensionFromName(gasFilename);
}
```
6. **Add architecture documentation** (30 minutes)
- Document filename conventions in CLAUDE.md
- Add examples of correct usage
#### Low Priority (Consider for Future)
7. **Introduce branded types** (4 hours)
- Create `GasFilename` and `LocalFilename` types
- Update all function signatures
- Let TypeScript enforce correct usage
8. **Create FilePathContext class** (6 hours)
- Encapsulate filename/extension/path logic
- Eliminate dual-variable pattern
- Reduce cognitive overhead
---
## Checklist for Reviewer
### Correctness ✅
- [x] Fix solves the immediate problem
- [x] No other instances of the bug exist
- [x] Edge cases handled correctly
- [x] Logic is sound
### Consistency ✅
- [x] Consistent with GitOperationManager pattern
- [x] Follows existing conventions
- [x] No contradictions introduced
### Testing ❌
- [ ] Unit tests exist for hook integration
- [ ] Integration tests cover this flow
- [ ] Regression test added
- [ ] Edge cases tested
### Documentation ⚠️
- [x] Inline comment explains the fix
- [ ] Function JSDoc mentions extension requirement
- [ ] Architecture documentation updated
### Security ✅
- [x] No command injection risk
- [x] Path traversal prevented
- [x] Input validation present
### Performance ✅
- [x] No meaningful overhead
- [x] No algorithmic changes
### Code Quality ⚠️
- [ ] No variable naming confusion (filename vs fullFilename still confusing)
- [ ] No code duplication (extension logic duplicated)
- [ ] No type safety issues (no branded types)
---
## Conclusion
**STATUS:** ✅ **FIX IS CORRECT AND SAFE TO DEPLOY**
**Confidence:** HIGH
**Reasoning:**
1. The fix directly addresses the root cause (missing file extension in git operations)
2. No other instances of the bug exist in the codebase
3. All edge cases are handled correctly by existing code
4. No security or performance issues introduced
5. Consistent with established patterns in GitOperationManager
**However:**
- **Test coverage is insufficient** - Should add regression test before deploying
- **Architectural debt exists** - Consider refactoring to eliminate filename confusion
- **Documentation is incomplete** - Update JSDoc and architecture docs
**Recommended Actions Before Deployment:**
1. ✅ **Deploy the fix** - It's correct and solves the problem
2. 📋 **Add regression test** - Prevent the bug from coming back
3. 📋 **Update JSDoc** - Document extension requirement
4. 📋 **Plan refactoring** - Address architectural debt in next sprint
**Overall Assessment:** The fix is correct, complete, and ready for deployment. The broader architectural issues should be addressed in a separate refactoring effort.
---
## Reviewer Sign-Off
**Reviewed by:** Claude Code
**Date:** 2026-01-01
**Status:** ✅ APPROVED (with recommendations)
**Next Steps:**
1. Deploy the fix immediately
2. Add regression test within 24 hours
3. Schedule refactoring for next sprint
