opencode-conductor-cdd-plugin 1.0.0-beta.17 → 1.0.0-beta.18

package/dist/utils/archive-tracks.js

@@ -1 +1,154 @@
-export {};
+/**
+ * Parses metadata.json content and validates required fields
+ */
+export function parseMetadata(jsonContent) {
+    const data = JSON.parse(jsonContent);
+    // Validate required fields
+    const requiredFields = ['track_id', 'type', 'status', 'created_at', 'updated_at', 'description'];
+    for (const field of requiredFields) {
+        if (!(field in data)) {
+            throw new Error(`Invalid metadata: missing required field '${field}'`);
+        }
+    }
+    return data;
+}
+/**
+ * Checks if all tasks in a plan.md file are marked as completed
+ * Looks for task markers: [x] = complete, [ ] = incomplete, [~] = in-progress
+ */
+export function isPlanFullyCompleted(planContent) {
+    // Match all task markers: - [x], - [ ], - [~]
+    const taskRegex = /^[\s]*-\s*\[([x ~]|\s)\]/gm;
+    const matches = planContent.match(taskRegex);
+    // If no tasks found, consider it complete (no work to do)
+    if (!matches || matches.length === 0) {
+        return true;
+    }
+    // Check if all tasks are marked with [x]
+    return matches.every(match => match.includes('[x]'));
+}
+/**
+ * Determines if a track is finished by checking both metadata status and plan completion
+ */
+export function isTrackFinished(metadata, planContent) {
+    const isMetadataComplete = metadata.status === 'completed';
+    const isPlanComplete = isPlanFullyCompleted(planContent);
+    return isMetadataComplete && isPlanComplete;
+}
+/**
+ * Moves a track directory from tracks/ to archive/
+ * Creates the archive directory if it doesn't exist
+ */
+export function moveTrackToArchive(projectRoot, trackId) {
+    const { existsSync, mkdirSync } = require('fs');
+    const { join } = require('path');
+    const { execSync } = require('child_process');
+    const tracksDir = join(projectRoot, 'conductor-cdd', 'tracks');
+    const archiveDir = join(projectRoot, 'conductor-cdd', 'archive');
+    const sourcePath = join(tracksDir, trackId);
+    const destPath = join(archiveDir, trackId);
+    // Verify source exists
+    if (!existsSync(sourcePath)) {
+        throw new Error(`Track directory not found: ${sourcePath}`);
+    }
+    // Create archive directory if needed
+    if (!existsSync(archiveDir)) {
+        mkdirSync(archiveDir, { recursive: true });
+    }
+    // Use mv command to move the directory
+    execSync(`mv "${sourcePath}" "${destPath}"`);
+}
+/**
+ * Removes a track entry from tracks.md registry file
+ * Handles the track block and its surrounding separator lines
+ */
+export function removeTrackFromRegistry(tracksFilePath, trackId) {
+    const { readFileSync, writeFileSync } = require('fs');
+    let content = readFileSync(tracksFilePath, 'utf-8');
+    // Split by separator to get track blocks
+    const separator = '\n---\n';
+    const parts = content.split(separator);
+    // Filter out the block containing the trackId
+    const filteredParts = parts.filter((part) => {
+        // Check if this part contains a link to the track we want to remove
+        return !part.includes(`./tracks/${trackId}/`);
+    });
+    // If nothing was filtered, track wasn't found - that's okay
+    if (filteredParts.length === parts.length) {
+        return;
+    }
+    // Rejoin with separator
+    content = filteredParts.join(separator);
+    writeFileSync(tracksFilePath, content, 'utf-8');
+}
+/**
+ * Main function to archive all completed tracks in a project
+ * Scans tracks/ directory, identifies completed tracks, and archives them
+ */
+export function archiveCompletedTracks(projectRoot) {
+    const { readdirSync, readFileSync, existsSync } = require('fs');
+    const { join } = require('path');
+    const result = {
+        archived: [],
+        skipped: [],
+        errors: []
+    };
+    const cddDir = join(projectRoot, 'conductor-cdd');
+    const tracksDir = join(cddDir, 'tracks');
+    const tracksFile = join(cddDir, 'tracks.md');
+    // Check if tracks directory exists
+    if (!existsSync(tracksDir)) {
+        return result;
+    }
+    // Get all track directories
+    const trackDirs = readdirSync(tracksDir, { withFileTypes: true })
+        .filter((dirent) => dirent.isDirectory())
+        .map((dirent) => dirent.name);
+    // Process each track
+    for (const trackId of trackDirs) {
+        try {
+            const trackPath = join(tracksDir, trackId);
+            const metadataPath = join(trackPath, 'metadata.json');
+            const planPath = join(trackPath, 'plan.md');
+            // Check if required files exist
+            if (!existsSync(metadataPath)) {
+                result.errors.push({
+                    trackId,
+                    error: 'metadata.json not found'
+                });
+                continue;
+            }
+            if (!existsSync(planPath)) {
+                result.errors.push({
+                    trackId,
+                    error: 'plan.md not found'
+                });
+                continue;
+            }
+            // Parse metadata and plan
+            const metadataContent = readFileSync(metadataPath, 'utf-8');
+            const planContent = readFileSync(planPath, 'utf-8');
+            const metadata = parseMetadata(metadataContent);
+            // Check if track is finished
+            if (isTrackFinished(metadata, planContent)) {
+                // Archive the track
+                moveTrackToArchive(projectRoot, trackId);
+                // Remove from tracks.md if it exists
+                if (existsSync(tracksFile)) {
+                    removeTrackFromRegistry(tracksFile, trackId);
+                }
+                result.archived.push(trackId);
+            }
+            else {
+                result.skipped.push(trackId);
+            }
+        }
+        catch (error) {
+            result.errors.push({
+                trackId,
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+    return result;
+}

package/dist/utils/archive-tracks.test.d.ts

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

package/dist/utils/archive-tracks.test.js

@@ -0,0 +1,495 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { isTrackFinished, parseMetadata, isPlanFullyCompleted, moveTrackToArchive, removeTrackFromRegistry, archiveCompletedTracks } from './archive-tracks.js';
+import { mkdirSync, writeFileSync, existsSync, readFileSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+describe('archive-tracks', () => {
+    describe('parseMetadata', () => {
+        it('should parse valid metadata.json content', () => {
+            const jsonContent = JSON.stringify({
+                track_id: 'test_track_001',
+                type: 'feature',
+                status: 'completed',
+                created_at: '2026-01-19T00:00:00Z',
+                updated_at: '2026-01-19T12:00:00Z',
+                description: 'Test track'
+            });
+            const result = parseMetadata(jsonContent);
+            expect(result).toEqual({
+                track_id: 'test_track_001',
+                type: 'feature',
+                status: 'completed',
+                created_at: '2026-01-19T00:00:00Z',
+                updated_at: '2026-01-19T12:00:00Z',
+                description: 'Test track'
+            });
+        });
+        it('should throw error for invalid JSON', () => {
+            expect(() => parseMetadata('invalid json')).toThrow();
+        });
+        it('should throw error for missing required fields', () => {
+            const jsonContent = JSON.stringify({
+                track_id: 'test_track_001'
+            });
+            expect(() => parseMetadata(jsonContent)).toThrow('Invalid metadata');
+        });
+    });
+    describe('isPlanFullyCompleted', () => {
+        it('should return true when all tasks are marked as completed', () => {
+            const planContent = `
+# Plan
+
+## Phase 1
+- [x] Task 1
+- [x] Task 2
+
+## Phase 2
+- [x] Task 3
+`;
+            expect(isPlanFullyCompleted(planContent)).toBe(true);
+        });
+        it('should return false when any task is incomplete', () => {
+            const planContent = `
+# Plan
+
+## Phase 1
+- [x] Task 1
+- [ ] Task 2
+
+## Phase 2
+- [x] Task 3
+`;
+            expect(isPlanFullyCompleted(planContent)).toBe(false);
+        });
+        it('should return false when there are in-progress tasks', () => {
+            const planContent = `
+# Plan
+
+## Phase 1
+- [x] Task 1
+- [~] Task 2
+
+## Phase 2
+- [x] Task 3
+`;
+            expect(isPlanFullyCompleted(planContent)).toBe(false);
+        });
+        it('should return true for plan with no tasks', () => {
+            const planContent = `
+# Plan
+
+Just a description, no tasks.
+`;
+            expect(isPlanFullyCompleted(planContent)).toBe(true);
+        });
+        it('should handle nested sub-tasks correctly', () => {
+            const planContent = `
+## Phase 1
+- [x] Task 1
+  - [x] Subtask 1.1
+  - [x] Subtask 1.2
+- [x] Task 2
+`;
+            expect(isPlanFullyCompleted(planContent)).toBe(true);
+        });
+        it('should return false if any sub-task is incomplete', () => {
+            const planContent = `
+## Phase 1
+- [x] Task 1
+  - [x] Subtask 1.1
+  - [ ] Subtask 1.2
+- [x] Task 2
+`;
+            expect(isPlanFullyCompleted(planContent)).toBe(false);
+        });
+    });
+    describe('isTrackFinished', () => {
+        it('should return true when metadata is completed and plan is fully checked', () => {
+            const metadata = {
+                track_id: 'test_001',
+                type: 'feature',
+                status: 'completed',
+                created_at: '2026-01-19T00:00:00Z',
+                updated_at: '2026-01-19T12:00:00Z',
+                description: 'Test'
+            };
+            const planContent = `
+## Phase 1
+- [x] Task 1
+- [x] Task 2
+`;
+            expect(isTrackFinished(metadata, planContent)).toBe(true);
+        });
+        it('should return false when metadata status is not completed', () => {
+            const metadata = {
+                track_id: 'test_001',
+                type: 'feature',
+                status: 'in_progress',
+                created_at: '2026-01-19T00:00:00Z',
+                updated_at: '2026-01-19T12:00:00Z',
+                description: 'Test'
+            };
+            const planContent = `
+## Phase 1
+- [x] Task 1
+- [x] Task 2
+`;
+            expect(isTrackFinished(metadata, planContent)).toBe(false);
+        });
+        it('should return false when plan has incomplete tasks', () => {
+            const metadata = {
+                track_id: 'test_001',
+                type: 'feature',
+                status: 'completed',
+                created_at: '2026-01-19T00:00:00Z',
+                updated_at: '2026-01-19T12:00:00Z',
+                description: 'Test'
+            };
+            const planContent = `
+## Phase 1
+- [x] Task 1
+- [ ] Task 2
+`;
+            expect(isTrackFinished(metadata, planContent)).toBe(false);
+        });
+        it('should return false when both metadata and plan are incomplete', () => {
+            const metadata = {
+                track_id: 'test_001',
+                type: 'feature',
+                status: 'new',
+                created_at: '2026-01-19T00:00:00Z',
+                updated_at: '2026-01-19T12:00:00Z',
+                description: 'Test'
+            };
+            const planContent = `
+## Phase 1
+- [ ] Task 1
+- [ ] Task 2
+`;
+            expect(isTrackFinished(metadata, planContent)).toBe(false);
+        });
+    });
+    describe('moveTrackToArchive', () => {
+        let testDir;
+        let tracksDir;
+        let archiveDir;
+        beforeEach(() => {
+            // Create temporary test directory structure
+            testDir = join(tmpdir(), `archive-test-${Date.now()}`);
+            tracksDir = join(testDir, 'conductor-cdd', 'tracks');
+            archiveDir = join(testDir, 'conductor-cdd', 'archive');
+            mkdirSync(tracksDir, { recursive: true });
+        });
+        afterEach(() => {
+            // Clean up test directory
+            if (existsSync(testDir)) {
+                rmSync(testDir, { recursive: true, force: true });
+            }
+        });
+        it('should move track directory to archive', () => {
+            const trackId = 'test_track_001';
+            const trackPath = join(tracksDir, trackId);
+            // Create track directory with files
+            mkdirSync(trackPath);
+            writeFileSync(join(trackPath, 'spec.md'), '# Spec');
+            writeFileSync(join(trackPath, 'plan.md'), '# Plan');
+            // Move to archive
+            moveTrackToArchive(testDir, trackId);
+            // Verify track no longer in tracks/
+            expect(existsSync(trackPath)).toBe(false);
+            // Verify track now in archive/
+            const archivedPath = join(archiveDir, trackId);
+            expect(existsSync(archivedPath)).toBe(true);
+            expect(existsSync(join(archivedPath, 'spec.md'))).toBe(true);
+            expect(existsSync(join(archivedPath, 'plan.md'))).toBe(true);
+        });
+        it('should create archive directory if it does not exist', () => {
+            const trackId = 'test_track_002';
+            const trackPath = join(tracksDir, trackId);
+            mkdirSync(trackPath);
+            writeFileSync(join(trackPath, 'spec.md'), '# Spec');
+            // Archive dir should not exist yet
+            expect(existsSync(archiveDir)).toBe(false);
+            // Move to archive
+            moveTrackToArchive(testDir, trackId);
+            // Archive dir should now exist
+            expect(existsSync(archiveDir)).toBe(true);
+            expect(existsSync(join(archiveDir, trackId))).toBe(true);
+        });
+        it('should throw error if source track does not exist', () => {
+            expect(() => moveTrackToArchive(testDir, 'nonexistent_track')).toThrow();
+        });
+    });
+    describe('removeTrackFromRegistry', () => {
+        let testDir;
+        let tracksFile;
+        beforeEach(() => {
+            testDir = join(tmpdir(), `registry-test-${Date.now()}`);
+            mkdirSync(testDir, { recursive: true });
+            tracksFile = join(testDir, 'tracks.md');
+        });
+        afterEach(() => {
+            if (existsSync(testDir)) {
+                rmSync(testDir, { recursive: true, force: true });
+            }
+        });
+        it('should remove track entry from tracks.md', () => {
+            const tracksContent = `# Project Tracks
+
+---
+
+- [x] **Track: First Track**
+*Link: [./tracks/first_track/](./tracks/first_track/)*
+
+---
+
+- [x] **Track: Second Track**
+*Link: [./tracks/second_track/](./tracks/second_track/)*
+
+---
+
+- [~] **Track: Third Track**
+*Link: [./tracks/third_track/](./tracks/third_track/)*
+`;
+            writeFileSync(tracksFile, tracksContent);
+            // Remove second track
+            removeTrackFromRegistry(tracksFile, 'second_track');
+            const updatedContent = readFileSync(tracksFile, 'utf-8');
+            // Should not contain second track
+            expect(updatedContent).not.toContain('Second Track');
+            expect(updatedContent).not.toContain('second_track');
+            // Should still contain other tracks
+            expect(updatedContent).toContain('First Track');
+            expect(updatedContent).toContain('Third Track');
+        });
+        it('should handle track entry with separator lines correctly', () => {
+            const tracksContent = `# Project Tracks
+
+---
+
+- [x] **Track: Keep This**
+*Link: [./tracks/keep_this/](./tracks/keep_this/)*
+
+---
+
+- [x] **Track: Remove This**
+*Link: [./tracks/remove_this/](./tracks/remove_this/)*
+
+---
+
+- [~] **Track: Also Keep**
+*Link: [./tracks/also_keep/](./tracks/also_keep/)*
+`;
+            writeFileSync(tracksFile, tracksContent);
+            removeTrackFromRegistry(tracksFile, 'remove_this');
+            const updatedContent = readFileSync(tracksFile, 'utf-8');
+            expect(updatedContent).not.toContain('Remove This');
+            expect(updatedContent).toContain('Keep This');
+            expect(updatedContent).toContain('Also Keep');
+            // Should have clean separator lines (no duplicate ---)
+            const separatorCount = (updatedContent.match(/^---$/gm) || []).length;
+            expect(separatorCount).toBe(2); // One separator between each remaining track
+        });
+        it('should do nothing if track not found in registry', () => {
+            const tracksContent = `# Project Tracks
+
+- [x] **Track: Some Track**
+*Link: [./tracks/some_track/](./tracks/some_track/)*
+`;
+            writeFileSync(tracksFile, tracksContent);
+            // Try to remove non-existent track
+            removeTrackFromRegistry(tracksFile, 'nonexistent');
+            const updatedContent = readFileSync(tracksFile, 'utf-8');
+            // Content should be unchanged
+            expect(updatedContent).toBe(tracksContent);
+        });
+    });
+    describe('archiveCompletedTracks (Integration)', () => {
+        let testDir;
+        let tracksDir;
+        let archiveDir;
+        let tracksFile;
+        beforeEach(() => {
+            testDir = join(tmpdir(), `archive-integration-${Date.now()}`);
+            const cddDir = join(testDir, 'conductor-cdd');
+            tracksDir = join(cddDir, 'tracks');
+            archiveDir = join(cddDir, 'archive');
+            tracksFile = join(cddDir, 'tracks.md');
+            mkdirSync(tracksDir, { recursive: true });
+        });
+        afterEach(() => {
+            if (existsSync(testDir)) {
+                rmSync(testDir, { recursive: true, force: true });
+            }
+        });
+        it('should archive tracks that are fully completed', () => {
+            // Create completed track
+            const completedTrackId = 'completed_track_001';
+            const completedPath = join(tracksDir, completedTrackId);
+            mkdirSync(completedPath);
+            const completedMetadata = {
+                track_id: completedTrackId,
+                type: 'feature',
+                status: 'completed',
+                created_at: '2026-01-19T00:00:00Z',
+                updated_at: '2026-01-19T12:00:00Z',
+                description: 'Completed track'
+            };
+            const completedPlan = `
+## Phase 1
+- [x] Task 1
+- [x] Task 2
+`;
+            writeFileSync(join(completedPath, 'metadata.json'), JSON.stringify(completedMetadata, null, 2));
+            writeFileSync(join(completedPath, 'plan.md'), completedPlan);
+            writeFileSync(join(completedPath, 'spec.md'), '# Spec');
+            // Create tracks.md
+            const tracksContent = `# Project Tracks
+
+---
+
+- [x] **Track: Completed Track**
+*Link: [./tracks/${completedTrackId}/](./tracks/${completedTrackId}/)*
+
+---
+`;
+            writeFileSync(tracksFile, tracksContent);
+            // Run archival
+            const result = archiveCompletedTracks(testDir);
+            // Verify track was archived
+            expect(result.archived).toContain(completedTrackId);
+            expect(result.errors).toHaveLength(0);
+            // Verify track moved to archive
+            expect(existsSync(completedPath)).toBe(false);
+            expect(existsSync(join(archiveDir, completedTrackId))).toBe(true);
+            // Verify removed from tracks.md
+            const updatedTracks = readFileSync(tracksFile, 'utf-8');
+            expect(updatedTracks).not.toContain(completedTrackId);
+        });
+        it('should skip tracks that are not completed', () => {
+            // Create incomplete track (metadata complete but plan incomplete)
+            const incompleteTrackId = 'incomplete_track_001';
+            const incompletePath = join(tracksDir, incompleteTrackId);
+            mkdirSync(incompletePath);
+            const incompleteMetadata = {
+                track_id: incompleteTrackId,
+                type: 'feature',
+                status: 'completed',
+                created_at: '2026-01-19T00:00:00Z',
+                updated_at: '2026-01-19T12:00:00Z',
+                description: 'Incomplete track'
+            };
+            const incompletePlan = `
+## Phase 1
+- [x] Task 1
+- [ ] Task 2
+`;
+            writeFileSync(join(incompletePath, 'metadata.json'), JSON.stringify(incompleteMetadata, null, 2));
+            writeFileSync(join(incompletePath, 'plan.md'), incompletePlan);
+            const tracksContent = `# Project Tracks
+
+---
+
+- [~] **Track: Incomplete Track**
+*Link: [./tracks/${incompleteTrackId}/](./tracks/${incompleteTrackId}/)*
+
+---
+`;
+            writeFileSync(tracksFile, tracksContent);
+            // Run archival
+            const result = archiveCompletedTracks(testDir);
+            // Verify track was skipped
+            expect(result.skipped).toContain(incompleteTrackId);
+            expect(result.archived).not.toContain(incompleteTrackId);
+            // Verify track still in tracks/
+            expect(existsSync(incompletePath)).toBe(true);
+            expect(existsSync(join(archiveDir, incompleteTrackId))).toBe(false);
+        });
+        it('should handle multiple tracks correctly', () => {
+            // Create 2 completed tracks and 1 incomplete
+            const completed1 = 'completed_001';
+            const completed2 = 'completed_002';
+            const incomplete1 = 'incomplete_001';
+            for (const trackId of [completed1, completed2]) {
+                const trackPath = join(tracksDir, trackId);
+                mkdirSync(trackPath);
+                writeFileSync(join(trackPath, 'metadata.json'), JSON.stringify({
+                    track_id: trackId,
+                    type: 'feature',
+                    status: 'completed',
+                    created_at: '2026-01-19T00:00:00Z',
+                    updated_at: '2026-01-19T12:00:00Z',
+                    description: 'Completed'
+                }, null, 2));
+                writeFileSync(join(trackPath, 'plan.md'), '## Phase 1\n- [x] Task 1');
+            }
+            const incompletePath = join(tracksDir, incomplete1);
+            mkdirSync(incompletePath);
+            writeFileSync(join(incompletePath, 'metadata.json'), JSON.stringify({
+                track_id: incomplete1,
+                type: 'feature',
+                status: 'in_progress',
+                created_at: '2026-01-19T00:00:00Z',
+                updated_at: '2026-01-19T12:00:00Z',
+                description: 'In progress'
+            }, null, 2));
+            writeFileSync(join(incompletePath, 'plan.md'), '## Phase 1\n- [x] Task 1');
+            const tracksContent = `# Project Tracks
+
+---
+
+- [x] **Track: Completed 1**
+*Link: [./tracks/${completed1}/](./tracks/${completed1}/)*
+
+---
+
+- [x] **Track: Completed 2**
+*Link: [./tracks/${completed2}/](./tracks/${completed2}/)*
+
+---
+
+- [~] **Track: Incomplete 1**
+*Link: [./tracks/${incomplete1}/](./tracks/${incomplete1}/)*
+
+---
+`;
+            writeFileSync(tracksFile, tracksContent);
+            // Run archival
+            const result = archiveCompletedTracks(testDir);
+            // Verify results
+            expect(result.archived).toHaveLength(2);
+            expect(result.archived).toContain(completed1);
+            expect(result.archived).toContain(completed2);
+            expect(result.skipped).toContain(incomplete1);
+            // Verify filesystem state
+            expect(existsSync(join(tracksDir, completed1))).toBe(false);
+            expect(existsSync(join(tracksDir, completed2))).toBe(false);
+            expect(existsSync(join(tracksDir, incomplete1))).toBe(true);
+            expect(existsSync(join(archiveDir, completed1))).toBe(true);
+            expect(existsSync(join(archiveDir, completed2))).toBe(true);
+        });
+        it('should handle tracks with missing metadata.json gracefully', () => {
+            const trackId = 'missing_metadata_001';
+            const trackPath = join(tracksDir, trackId);
+            mkdirSync(trackPath);
+            writeFileSync(join(trackPath, 'plan.md'), '## Phase 1\n- [x] Task 1');
+            const tracksContent = `# Project Tracks
+
+---
+
+- [x] **Track: Missing Metadata**
+*Link: [./tracks/${trackId}/](./tracks/${trackId}/)*
+
+---
+`;
+            writeFileSync(tracksFile, tracksContent);
+            // Run archival
+            const result = archiveCompletedTracks(testDir);
+            // Should record an error
+            expect(result.errors).toHaveLength(1);
+            expect(result.errors[0].trackId).toBe(trackId);
+            // Track should still exist
+            expect(existsSync(trackPath)).toBe(true);
+        });
+    });
+});

package/dist/utils/metadataTracker.d.ts

@@ -0,0 +1,39 @@
+export type TaskStatus = "pending" | "in_progress" | "completed" | "cancelled";
+export type PhaseStatus = "pending" | "in_progress" | "completed";
+export interface TaskMetadata {
+    taskId: string;
+    taskName: string;
+    status: TaskStatus;
+    commitSha?: string;
+    startedAt?: string;
+    completedAt?: string;
+}
+export interface PhaseMetadata {
+    phaseId: string;
+    phaseName: string;
+    status: PhaseStatus;
+    checkpointSha?: string;
+    tasks: TaskMetadata[];
+}
+export interface TrackMetadata {
+    trackId: string;
+    trackName: string;
+    phases: PhaseMetadata[];
+    createdAt: string;
+    updatedAt: string;
+    completedAt?: string;
+}
+export declare class MetadataTracker {
+    private workDir;
+    private trackId;
+    private metadataPath;
+    constructor(workDir: string, trackId: string);
+    private ensureDirectory;
+    initializeMetadata(metadata: TrackMetadata): void;
+    readMetadata(): TrackMetadata | null;
+    private writeMetadata;
+    updateTaskStatus(phaseId: string, taskId: string, status: TaskStatus, commitSha?: string): void;
+    updatePhaseStatus(phaseId: string, status: PhaseStatus, checkpointSha?: string): void;
+    getActivePhase(): PhaseMetadata | null;
+    getActiveTask(): TaskMetadata | null;
+}