@gitgov/core 1.7.0 → 1.8.0

package/dist/src/index.d.ts

@@ -751,39 +751,39 @@ declare class GitGovError extends Error {
     constructor(message: string, code: string);
 }
 
-type index$k_ActorPayload = ActorPayload;
-type index$k_ActorRecord = ActorRecord;
-type index$k_AgentPayload = AgentPayload;
-type index$k_AgentRecord = AgentRecord;
-type index$k_ChangelogPayload = ChangelogPayload;
-type index$k_ChangelogRecord = ChangelogRecord;
-type index$k_CustomRecord = CustomRecord;
-type index$k_CyclePayload = CyclePayload;
-type index$k_CycleRecord = CycleRecord;
-type index$k_EmbeddedMetadataHeader = EmbeddedMetadataHeader;
-type index$k_EmbeddedMetadataRecord<T extends GitGovRecordPayload> = EmbeddedMetadataRecord<T>;
-type index$k_ExecutionPayload = ExecutionPayload;
-type index$k_ExecutionRecord = ExecutionRecord;
-type index$k_FeedbackPayload = FeedbackPayload;
-type index$k_FeedbackRecord = FeedbackRecord;
-type index$k_GitGovActorRecord = GitGovActorRecord;
-type index$k_GitGovAgentRecord = GitGovAgentRecord;
-type index$k_GitGovChangelogRecord = GitGovChangelogRecord;
-type index$k_GitGovCycleRecord = GitGovCycleRecord;
-type index$k_GitGovError = GitGovError;
-declare const index$k_GitGovError: typeof GitGovError;
-type index$k_GitGovExecutionRecord = GitGovExecutionRecord;
-type index$k_GitGovFeedbackRecord = GitGovFeedbackRecord;
-type index$k_GitGovRecord = GitGovRecord;
-type index$k_GitGovRecordPayload = GitGovRecordPayload;
-type index$k_GitGovRecordType = GitGovRecordType;
-type index$k_GitGovTaskRecord = GitGovTaskRecord;
-type index$k_Signature = Signature;
-type index$k_TaskPayload = TaskPayload;
-type index$k_TaskRecord = TaskRecord;
-type index$k_WorkflowMethodologyRecord = WorkflowMethodologyRecord;
-declare namespace index$k {
-  export { type index$k_ActorPayload as ActorPayload, type index$k_ActorRecord as ActorRecord, type index$k_AgentPayload as AgentPayload, type index$k_AgentRecord as AgentRecord, type index$k_ChangelogPayload as ChangelogPayload, type index$k_ChangelogRecord as ChangelogRecord, type index$k_CustomRecord as CustomRecord, type index$k_CyclePayload as CyclePayload, type index$k_CycleRecord as CycleRecord, type index$k_EmbeddedMetadataHeader as EmbeddedMetadataHeader, type index$k_EmbeddedMetadataRecord as EmbeddedMetadataRecord, type index$k_ExecutionPayload as ExecutionPayload, type index$k_ExecutionRecord as ExecutionRecord, type index$k_FeedbackPayload as FeedbackPayload, type index$k_FeedbackRecord as FeedbackRecord, type index$k_GitGovActorRecord as GitGovActorRecord, type index$k_GitGovAgentRecord as GitGovAgentRecord, type index$k_GitGovChangelogRecord as GitGovChangelogRecord, type index$k_GitGovCycleRecord as GitGovCycleRecord, index$k_GitGovError as GitGovError, type index$k_GitGovExecutionRecord as GitGovExecutionRecord, type index$k_GitGovFeedbackRecord as GitGovFeedbackRecord, type index$k_GitGovRecord as GitGovRecord, type index$k_GitGovRecordPayload as GitGovRecordPayload, type index$k_GitGovRecordType as GitGovRecordType, type index$k_GitGovTaskRecord as GitGovTaskRecord, type index$k_Signature as Signature, type index$k_TaskPayload as TaskPayload, type index$k_TaskRecord as TaskRecord, type index$k_WorkflowMethodologyRecord as WorkflowMethodologyRecord };
+type index$m_ActorPayload = ActorPayload;
+type index$m_ActorRecord = ActorRecord;
+type index$m_AgentPayload = AgentPayload;
+type index$m_AgentRecord = AgentRecord;
+type index$m_ChangelogPayload = ChangelogPayload;
+type index$m_ChangelogRecord = ChangelogRecord;
+type index$m_CustomRecord = CustomRecord;
+type index$m_CyclePayload = CyclePayload;
+type index$m_CycleRecord = CycleRecord;
+type index$m_EmbeddedMetadataHeader = EmbeddedMetadataHeader;
+type index$m_EmbeddedMetadataRecord<T extends GitGovRecordPayload> = EmbeddedMetadataRecord<T>;
+type index$m_ExecutionPayload = ExecutionPayload;
+type index$m_ExecutionRecord = ExecutionRecord;
+type index$m_FeedbackPayload = FeedbackPayload;
+type index$m_FeedbackRecord = FeedbackRecord;
+type index$m_GitGovActorRecord = GitGovActorRecord;
+type index$m_GitGovAgentRecord = GitGovAgentRecord;
+type index$m_GitGovChangelogRecord = GitGovChangelogRecord;
+type index$m_GitGovCycleRecord = GitGovCycleRecord;
+type index$m_GitGovError = GitGovError;
+declare const index$m_GitGovError: typeof GitGovError;
+type index$m_GitGovExecutionRecord = GitGovExecutionRecord;
+type index$m_GitGovFeedbackRecord = GitGovFeedbackRecord;
+type index$m_GitGovRecord = GitGovRecord;
+type index$m_GitGovRecordPayload = GitGovRecordPayload;
+type index$m_GitGovRecordType = GitGovRecordType;
+type index$m_GitGovTaskRecord = GitGovTaskRecord;
+type index$m_Signature = Signature;
+type index$m_TaskPayload = TaskPayload;
+type index$m_TaskRecord = TaskRecord;
+type index$m_WorkflowMethodologyRecord = WorkflowMethodologyRecord;
+declare namespace index$m {
+  export { type index$m_ActorPayload as ActorPayload, type index$m_ActorRecord as ActorRecord, type index$m_AgentPayload as AgentPayload, type index$m_AgentRecord as AgentRecord, type index$m_ChangelogPayload as ChangelogPayload, type index$m_ChangelogRecord as ChangelogRecord, type index$m_CustomRecord as CustomRecord, type index$m_CyclePayload as CyclePayload, type index$m_CycleRecord as CycleRecord, type index$m_EmbeddedMetadataHeader as EmbeddedMetadataHeader, type index$m_EmbeddedMetadataRecord as EmbeddedMetadataRecord, type index$m_ExecutionPayload as ExecutionPayload, type index$m_ExecutionRecord as ExecutionRecord, type index$m_FeedbackPayload as FeedbackPayload, type index$m_FeedbackRecord as FeedbackRecord, type index$m_GitGovActorRecord as GitGovActorRecord, type index$m_GitGovAgentRecord as GitGovAgentRecord, type index$m_GitGovChangelogRecord as GitGovChangelogRecord, type index$m_GitGovCycleRecord as GitGovCycleRecord, index$m_GitGovError as GitGovError, type index$m_GitGovExecutionRecord as GitGovExecutionRecord, type index$m_GitGovFeedbackRecord as GitGovFeedbackRecord, type index$m_GitGovRecord as GitGovRecord, type index$m_GitGovRecordPayload as GitGovRecordPayload, type index$m_GitGovRecordType as GitGovRecordType, type index$m_GitGovTaskRecord as GitGovTaskRecord, type index$m_Signature as Signature, type index$m_TaskPayload as TaskPayload, type index$m_TaskRecord as TaskRecord, type index$m_WorkflowMethodologyRecord as WorkflowMethodologyRecord };
 }
 
 type StorablePayload$1 = Exclude<GitGovRecordPayload, CustomRecord>;
@@ -816,11 +816,11 @@ declare class RecordStore<T extends StorablePayload$1> {
     exists(recordId: string): Promise<boolean>;
 }
 
-type index$j_FsDependencies = FsDependencies;
-type index$j_RecordStore<T extends StorablePayload$1> = RecordStore<T>;
-declare const index$j_RecordStore: typeof RecordStore;
-declare namespace index$j {
-  export { type index$j_FsDependencies as FsDependencies, index$j_RecordStore as RecordStore };
+type index$l_FsDependencies = FsDependencies;
+type index$l_RecordStore<T extends StorablePayload$1> = RecordStore<T>;
+declare const index$l_RecordStore: typeof RecordStore;
+declare namespace index$l {
+  export { type index$l_FsDependencies as FsDependencies, index$l_RecordStore as RecordStore };
 }
 
 /**
@@ -1180,31 +1180,31 @@ declare function publishEvent(event: GitGovEvent): void;
  */
 declare function subscribeToEvent<T extends GitGovEvent>(eventType: T['type'], handler: EventHandler<T>): EventSubscription;
 
-type index$i_ActivityEvent = ActivityEvent;
-type index$i_ActorCreatedEvent = ActorCreatedEvent;
-type index$i_ActorRevokedEvent = ActorRevokedEvent;
-type index$i_AgentRegisteredEvent = AgentRegisteredEvent;
-type index$i_BaseEvent = BaseEvent;
-type index$i_ChangelogCreatedEvent = ChangelogCreatedEvent;
-type index$i_CycleCreatedEvent = CycleCreatedEvent;
-type index$i_CycleStatusChangedEvent = CycleStatusChangedEvent;
-type index$i_EventBus = EventBus;
-declare const index$i_EventBus: typeof EventBus;
-type index$i_EventHandler<T extends BaseEvent = BaseEvent> = EventHandler<T>;
-type index$i_EventMetadata = EventMetadata;
-type index$i_EventSubscription = EventSubscription;
-type index$i_ExecutionCreatedEvent = ExecutionCreatedEvent;
-type index$i_FeedbackCreatedEvent = FeedbackCreatedEvent;
-type index$i_GitGovEvent = GitGovEvent;
-type index$i_IEventStream = IEventStream;
-type index$i_SystemDailyTickEvent = SystemDailyTickEvent;
-type index$i_TaskCreatedEvent = TaskCreatedEvent;
-type index$i_TaskStatusChangedEvent = TaskStatusChangedEvent;
-declare const index$i_eventBus: typeof eventBus;
-declare const index$i_publishEvent: typeof publishEvent;
-declare const index$i_subscribeToEvent: typeof subscribeToEvent;
-declare namespace index$i {
-  export { type index$i_ActivityEvent as ActivityEvent, type index$i_ActorCreatedEvent as ActorCreatedEvent, type index$i_ActorRevokedEvent as ActorRevokedEvent, type index$i_AgentRegisteredEvent as AgentRegisteredEvent, type index$i_BaseEvent as BaseEvent, type index$i_ChangelogCreatedEvent as ChangelogCreatedEvent, type index$i_CycleCreatedEvent as CycleCreatedEvent, type index$i_CycleStatusChangedEvent as CycleStatusChangedEvent, index$i_EventBus as EventBus, type index$i_EventHandler as EventHandler, type index$i_EventMetadata as EventMetadata, type index$i_EventSubscription as EventSubscription, type index$i_ExecutionCreatedEvent as ExecutionCreatedEvent, type index$i_FeedbackCreatedEvent as FeedbackCreatedEvent, type index$i_GitGovEvent as GitGovEvent, type index$i_IEventStream as IEventStream, type index$i_SystemDailyTickEvent as SystemDailyTickEvent, type index$i_TaskCreatedEvent as TaskCreatedEvent, type index$i_TaskStatusChangedEvent as TaskStatusChangedEvent, index$i_eventBus as eventBus, index$i_publishEvent as publishEvent, index$i_subscribeToEvent as subscribeToEvent };
+type index$k_ActivityEvent = ActivityEvent;
+type index$k_ActorCreatedEvent = ActorCreatedEvent;
+type index$k_ActorRevokedEvent = ActorRevokedEvent;
+type index$k_AgentRegisteredEvent = AgentRegisteredEvent;
+type index$k_BaseEvent = BaseEvent;
+type index$k_ChangelogCreatedEvent = ChangelogCreatedEvent;
+type index$k_CycleCreatedEvent = CycleCreatedEvent;
+type index$k_CycleStatusChangedEvent = CycleStatusChangedEvent;
+type index$k_EventBus = EventBus;
+declare const index$k_EventBus: typeof EventBus;
+type index$k_EventHandler<T extends BaseEvent = BaseEvent> = EventHandler<T>;
+type index$k_EventMetadata = EventMetadata;
+type index$k_EventSubscription = EventSubscription;
+type index$k_ExecutionCreatedEvent = ExecutionCreatedEvent;
+type index$k_FeedbackCreatedEvent = FeedbackCreatedEvent;
+type index$k_GitGovEvent = GitGovEvent;
+type index$k_IEventStream = IEventStream;
+type index$k_SystemDailyTickEvent = SystemDailyTickEvent;
+type index$k_TaskCreatedEvent = TaskCreatedEvent;
+type index$k_TaskStatusChangedEvent = TaskStatusChangedEvent;
+declare const index$k_eventBus: typeof eventBus;
+declare const index$k_publishEvent: typeof publishEvent;
+declare const index$k_subscribeToEvent: typeof subscribeToEvent;
+declare namespace index$k {
+  export { type index$k_ActivityEvent as ActivityEvent, type index$k_ActorCreatedEvent as ActorCreatedEvent, type index$k_ActorRevokedEvent as ActorRevokedEvent, type index$k_AgentRegisteredEvent as AgentRegisteredEvent, type index$k_BaseEvent as BaseEvent, type index$k_ChangelogCreatedEvent as ChangelogCreatedEvent, type index$k_CycleCreatedEvent as CycleCreatedEvent, type index$k_CycleStatusChangedEvent as CycleStatusChangedEvent, index$k_EventBus as EventBus, type index$k_EventHandler as EventHandler, type index$k_EventMetadata as EventMetadata, type index$k_EventSubscription as EventSubscription, type index$k_ExecutionCreatedEvent as ExecutionCreatedEvent, type index$k_FeedbackCreatedEvent as FeedbackCreatedEvent, type index$k_GitGovEvent as GitGovEvent, type index$k_IEventStream as IEventStream, type index$k_SystemDailyTickEvent as SystemDailyTickEvent, type index$k_TaskCreatedEvent as TaskCreatedEvent, type index$k_TaskStatusChangedEvent as TaskStatusChangedEvent, index$k_eventBus as eventBus, index$k_publishEvent as publishEvent, index$k_subscribeToEvent as subscribeToEvent };
 }
 
 /**
@@ -1284,12 +1284,12 @@ declare class IdentityAdapter implements IIdentityAdapter {
     listAgentRecords(): Promise<AgentRecord[]>;
 }
 
-type index$h_IIdentityAdapter = IIdentityAdapter;
-type index$h_IdentityAdapter = IdentityAdapter;
-declare const index$h_IdentityAdapter: typeof IdentityAdapter;
-type index$h_IdentityAdapterDependencies = IdentityAdapterDependencies;
-declare namespace index$h {
-  export { type index$h_IIdentityAdapter as IIdentityAdapter, index$h_IdentityAdapter as IdentityAdapter, type index$h_IdentityAdapterDependencies as IdentityAdapterDependencies };
+type index$j_IIdentityAdapter = IIdentityAdapter;
+type index$j_IdentityAdapter = IdentityAdapter;
+declare const index$j_IdentityAdapter: typeof IdentityAdapter;
+type index$j_IdentityAdapterDependencies = IdentityAdapterDependencies;
+declare namespace index$j {
+  export { type index$j_IIdentityAdapter as IIdentityAdapter, index$j_IdentityAdapter as IdentityAdapter, type index$j_IdentityAdapterDependencies as IdentityAdapterDependencies };
 }
 
 /**
@@ -1407,13 +1407,13 @@ declare class FeedbackAdapter implements IFeedbackAdapter {
     private buildThread;
 }
 
-type index$g_FeedbackAdapter = FeedbackAdapter;
-declare const index$g_FeedbackAdapter: typeof FeedbackAdapter;
-type index$g_FeedbackAdapterDependencies = FeedbackAdapterDependencies;
-type index$g_FeedbackThread = FeedbackThread;
-type index$g_IFeedbackAdapter = IFeedbackAdapter;
-declare namespace index$g {
-  export { index$g_FeedbackAdapter as FeedbackAdapter, type index$g_FeedbackAdapterDependencies as FeedbackAdapterDependencies, type index$g_FeedbackThread as FeedbackThread, type index$g_IFeedbackAdapter as IFeedbackAdapter };
+type index$i_FeedbackAdapter = FeedbackAdapter;
+declare const index$i_FeedbackAdapter: typeof FeedbackAdapter;
+type index$i_FeedbackAdapterDependencies = FeedbackAdapterDependencies;
+type index$i_FeedbackThread = FeedbackThread;
+type index$i_IFeedbackAdapter = IFeedbackAdapter;
+declare namespace index$i {
+  export { index$i_FeedbackAdapter as FeedbackAdapter, type index$i_FeedbackAdapterDependencies as FeedbackAdapterDependencies, type index$i_FeedbackThread as FeedbackThread, type index$i_IFeedbackAdapter as IFeedbackAdapter };
 }
 
 /**
@@ -1501,12 +1501,12 @@ declare class ExecutionAdapter implements IExecutionAdapter {
     private isFirstExecutionForTask;
 }
 
-type index$f_ExecutionAdapter = ExecutionAdapter;
-declare const index$f_ExecutionAdapter: typeof ExecutionAdapter;
-type index$f_ExecutionAdapterDependencies = ExecutionAdapterDependencies;
-type index$f_IExecutionAdapter = IExecutionAdapter;
-declare namespace index$f {
-  export { index$f_ExecutionAdapter as ExecutionAdapter, type index$f_ExecutionAdapterDependencies as ExecutionAdapterDependencies, type index$f_IExecutionAdapter as IExecutionAdapter };
+type index$h_ExecutionAdapter = ExecutionAdapter;
+declare const index$h_ExecutionAdapter: typeof ExecutionAdapter;
+type index$h_ExecutionAdapterDependencies = ExecutionAdapterDependencies;
+type index$h_IExecutionAdapter = IExecutionAdapter;
+declare namespace index$h {
+  export { index$h_ExecutionAdapter as ExecutionAdapter, type index$h_ExecutionAdapterDependencies as ExecutionAdapterDependencies, type index$h_IExecutionAdapter as IExecutionAdapter };
 }
 
 /**
@@ -1599,13 +1599,13 @@ declare class ChangelogAdapter implements IChangelogAdapter {
     getChangelogsByEntity(entityId: string, _entityType?: string): Promise<ChangelogRecord[]>;
 }
 
-type index$e_ChangelogAdapter = ChangelogAdapter;
-declare const index$e_ChangelogAdapter: typeof ChangelogAdapter;
-type index$e_ChangelogAdapterDependencies = ChangelogAdapterDependencies;
-type index$e_ChangelogListOptions = ChangelogListOptions;
-type index$e_IChangelogAdapter = IChangelogAdapter;
-declare namespace index$e {
-  export { index$e_ChangelogAdapter as ChangelogAdapter, type index$e_ChangelogAdapterDependencies as ChangelogAdapterDependencies, type index$e_ChangelogListOptions as ChangelogListOptions, type index$e_IChangelogAdapter as IChangelogAdapter };
+type index$g_ChangelogAdapter = ChangelogAdapter;
+declare const index$g_ChangelogAdapter: typeof ChangelogAdapter;
+type index$g_ChangelogAdapterDependencies = ChangelogAdapterDependencies;
+type index$g_ChangelogListOptions = ChangelogListOptions;
+type index$g_IChangelogAdapter = IChangelogAdapter;
+declare namespace index$g {
+  export { index$g_ChangelogAdapter as ChangelogAdapter, type index$g_ChangelogAdapterDependencies as ChangelogAdapterDependencies, type index$g_ChangelogListOptions as ChangelogListOptions, type index$g_IChangelogAdapter as IChangelogAdapter };
 }
 
 /**
@@ -1617,9 +1617,9 @@ type MetricsAdapterDependencies = {
     feedbackStore?: RecordStore<FeedbackRecord>;
     executionStore?: RecordStore<ExecutionRecord>;
     actorStore?: RecordStore<ActorRecord>;
-    platformApi?: IPlatformApi$1;
+    platformApi?: IPlatformApi;
 };
-interface IPlatformApi$1 {
+interface IPlatformApi {
     getTokenConsumption(timeframe: string): Promise<TokenConsumption[]>;
 }
 type TokenConsumption = {
@@ -1790,16 +1790,247 @@ declare class MetricsAdapter implements IMetricsAdapter {
     calculateAgentExecutionTime(_executions: ExecutionRecord[]): number;
 }
 
-type index$d_CollaborationMetrics = CollaborationMetrics;
-type index$d_IMetricsAdapter = IMetricsAdapter;
-type index$d_MetricsAdapter = MetricsAdapter;
-declare const index$d_MetricsAdapter: typeof MetricsAdapter;
-type index$d_MetricsAdapterDependencies = MetricsAdapterDependencies;
-type index$d_ProductivityMetrics = ProductivityMetrics;
-type index$d_SystemStatus = SystemStatus;
-type index$d_TaskHealthReport = TaskHealthReport;
-declare namespace index$d {
-  export { type index$d_CollaborationMetrics as CollaborationMetrics, type index$d_IMetricsAdapter as IMetricsAdapter, index$d_MetricsAdapter as MetricsAdapter, type index$d_MetricsAdapterDependencies as MetricsAdapterDependencies, type index$d_ProductivityMetrics as ProductivityMetrics, type index$d_SystemStatus as SystemStatus, type index$d_TaskHealthReport as TaskHealthReport };
+type index$f_CollaborationMetrics = CollaborationMetrics;
+type index$f_IMetricsAdapter = IMetricsAdapter;
+type index$f_MetricsAdapter = MetricsAdapter;
+declare const index$f_MetricsAdapter: typeof MetricsAdapter;
+type index$f_MetricsAdapterDependencies = MetricsAdapterDependencies;
+type index$f_ProductivityMetrics = ProductivityMetrics;
+type index$f_SystemStatus = SystemStatus;
+type index$f_TaskHealthReport = TaskHealthReport;
+declare namespace index$f {
+  export { type index$f_CollaborationMetrics as CollaborationMetrics, type index$f_IMetricsAdapter as IMetricsAdapter, index$f_MetricsAdapter as MetricsAdapter, type index$f_MetricsAdapterDependencies as MetricsAdapterDependencies, type index$f_ProductivityMetrics as ProductivityMetrics, type index$f_SystemStatus as SystemStatus, type index$f_TaskHealthReport as TaskHealthReport };
+}
+
+/**
+ * GitGovernance Configuration Types
+ * Based on config_file.md blueprint
+ */
+interface GitGovConfig {
+    protocolVersion: string;
+    projectId: string;
+    projectName: string;
+    rootCycle: string;
+    state?: {
+        branch?: string;
+        sync?: {
+            strategy?: "manual" | "immediate" | "batched";
+            maxRetries?: number;
+            pushIntervalSeconds?: number;
+            batchIntervalSeconds?: number;
+        };
+        defaults?: {
+            pullScheduler?: {
+                defaultIntervalSeconds?: number;
+                defaultEnabled?: boolean;
+                defaultContinueOnNetworkError?: boolean;
+                defaultStopOnConflict?: boolean;
+            };
+            fileWatcher?: {
+                defaultDebounceMs?: number;
+                defaultIgnoredPatterns?: string[];
+            };
+        };
+    };
+}
+/**
+ * GitGovernance Session State Types
+ * Based on session_state.md blueprint
+ */
+interface SyncStatus {
+    lastSyncPush?: string;
+    lastSyncPull?: string;
+    status?: 'synced' | 'pending' | 'pulling' | 'pushing' | 'conflict';
+    lastError?: string;
+}
+interface ActorState {
+    activeTaskId?: string | undefined;
+    activeCycleId?: string | undefined;
+    lastSync?: string;
+    syncStatus?: SyncStatus;
+    [key: string]: any;
+}
+interface GitGovSession {
+    cloud?: {
+        sessionToken?: string;
+    };
+    lastSession?: {
+        actorId: string;
+        timestamp: string;
+    };
+    actorState?: Record<string, ActorState>;
+    syncPreferences?: {
+        pullScheduler?: {
+            enabled?: boolean;
+            pullIntervalSeconds?: number;
+            continueOnNetworkError?: boolean;
+            stopOnConflict?: boolean;
+        };
+        fileWatcher?: {
+            enabled?: boolean;
+            debounceMs?: number;
+            ignoredPatterns?: string[];
+        };
+    };
+}
+/**
+ * Configuration Manager Class
+ * Provides typed access to GitGovernance configuration and session state
+ */
+declare class ConfigManager {
+    private configPath;
+    private sessionPath;
+    constructor(projectRootPath?: string);
+    /**
+     * Load GitGovernance configuration
+     */
+    loadConfig(): Promise<GitGovConfig | null>;
+    /**
+     * Load GitGovernance session state
+     */
+    loadSession(): Promise<GitGovSession | null>;
+    /**
+     * Get root cycle from configuration
+     */
+    getRootCycle(): Promise<string | null>;
+    /**
+     * Get project information from configuration
+     */
+    getProjectInfo(): Promise<{
+        id: string;
+        name: string;
+    } | null>;
+    /**
+     * Get actor state for a specific actor
+     */
+    getActorState(actorId: string): Promise<ActorState | null>;
+    /**
+     * Update actor state for a specific actor
+     */
+    updateActorState(actorId: string, state: Partial<ActorState>): Promise<void>;
+    /**
+     * Get cloud session token
+     */
+    getCloudSessionToken(): Promise<string | null>;
+    /**
+     * Get complete context information for an actor
+     * Useful for agents to understand current working context
+     * Returns information from both config.json (project-level) and .session.json (actor-level)
+     */
+    getActorContext(actorId: string): Promise<{
+        actorId: string;
+        activeCycleId: string | null;
+        activeTaskId: string | null;
+        rootCycle: string | null;
+        projectInfo: {
+            id: string;
+            name: string;
+        } | null;
+        syncStatus: SyncStatus | null;
+    }>;
+    /**
+     * Get sync configuration from config.json
+     * Returns sync strategy and related settings with defaults
+     */
+    getSyncConfig(): Promise<{
+        strategy: "manual" | "immediate" | "batched";
+        maxRetries: number;
+        pushIntervalSeconds: number;
+        batchIntervalSeconds: number;
+    } | null>;
+    /**
+     * Get sync defaults from config.json
+     * Returns recommended defaults for pullScheduler and fileWatcher
+     */
+    getSyncDefaults(): Promise<{
+        pullScheduler: {
+            defaultIntervalSeconds: number;
+            defaultEnabled: boolean;
+            defaultContinueOnNetworkError: boolean;
+            defaultStopOnConflict: boolean;
+        };
+        fileWatcher: {
+            defaultDebounceMs: number;
+            defaultIgnoredPatterns: string[];
+        };
+    }>;
+    /**
+     * Resolve PullScheduler configuration with priority logic:
+     * 1. Local preferences (.session.json syncPreferences)
+     * 2. Project defaults (config.json state.defaults)
+     * 3. Hardcoded fallbacks
+     */
+    resolvePullSchedulerConfig(): Promise<{
+        enabled: boolean;
+        pullIntervalSeconds: number;
+        continueOnNetworkError: boolean;
+        stopOnConflict: boolean;
+    }>;
+    /**
+     * Resolve FileWatcher configuration with priority logic:
+     * 1. Local preferences (.session.json syncPreferences)
+     * 2. Project defaults (config.json state.defaults)
+     * 3. Hardcoded fallbacks
+     */
+    resolveFileWatcherConfig(): Promise<{
+        enabled: boolean;
+        debounceMs: number;
+        ignoredPatterns: string[];
+    }>;
+    /**
+     * Update sync preferences in .session.json
+     * These are local machine preferences that override project defaults
+     */
+    updateSyncPreferences(preferences: {
+        pullScheduler?: Partial<{
+            enabled: boolean;
+            pullIntervalSeconds: number;
+            continueOnNetworkError: boolean;
+            stopOnConflict: boolean;
+        }>;
+        fileWatcher?: Partial<{
+            enabled: boolean;
+            debounceMs: number;
+            ignoredPatterns: string[];
+        }>;
+    }): Promise<void>;
+    /**
+     * Finds the project root by searching upwards for a .git directory.
+     * Caches the result for subsequent calls.
+     * @param startPath The path to start searching from. Defaults to the current working directory.
+     * @returns The absolute path to the project root, or null if not found.
+     */
+    static findProjectRoot(startPath?: string): string | null;
+    /**
+     * Finds the appropriate project root by searching upwards.
+     * First looks for .gitgov (initialized project), then .git (for init).
+     * @param startPath The path to start searching from. Defaults to the current working directory.
+     * @returns The absolute path to the project root, or null if not found.
+     */
+    static findGitgovRoot(startPath?: string): string | null;
+    /**
+     * Gets the .gitgov directory path from project root
+     */
+    static getGitgovPath(): string;
+    /**
+     * Checks if current directory is a GitGovernance project
+     */
+    static isGitgovProject(): boolean;
+}
+/**
+ * Create a ConfigManager instance for the current project
+ */
+declare function createConfigManager(projectRoot?: string): ConfigManager;
+
+type index$e_ActorState = ActorState;
+type index$e_ConfigManager = ConfigManager;
+declare const index$e_ConfigManager: typeof ConfigManager;
+type index$e_GitGovConfig = GitGovConfig;
+type index$e_GitGovSession = GitGovSession;
+type index$e_SyncStatus = SyncStatus;
+declare const index$e_createConfigManager: typeof createConfigManager;
+declare namespace index$e {
+  export { type index$e_ActorState as ActorState, index$e_ConfigManager as ConfigManager, type index$e_GitGovConfig as GitGovConfig, type index$e_GitGovSession as GitGovSession, type index$e_SyncStatus as SyncStatus, index$e_createConfigManager as createConfigManager };
 }
 
 type TaskStatus = TaskRecord['status'];
@@ -1871,12 +2102,12 @@ declare class WorkflowMethodologyAdapter implements IWorkflowMethodology {
     getAvailableTransitions(from: TaskStatus): Promise<TransitionRule[]>;
 }
 
-type index$c_IWorkflowMethodology = IWorkflowMethodology;
-type index$c_WorkflowMethodologyAdapter = WorkflowMethodologyAdapter;
-declare const index$c_WorkflowMethodologyAdapter: typeof WorkflowMethodologyAdapter;
-type index$c_WorkflowMethodologyAdapterDependencies = WorkflowMethodologyAdapterDependencies;
-declare namespace index$c {
-  export { type index$c_IWorkflowMethodology as IWorkflowMethodology, type ValidationContext$1 as ValidationContext, index$c_WorkflowMethodologyAdapter as WorkflowMethodologyAdapter, type index$c_WorkflowMethodologyAdapterDependencies as WorkflowMethodologyAdapterDependencies };
+type index$d_IWorkflowMethodology = IWorkflowMethodology;
+type index$d_WorkflowMethodologyAdapter = WorkflowMethodologyAdapter;
+declare const index$d_WorkflowMethodologyAdapter: typeof WorkflowMethodologyAdapter;
+type index$d_WorkflowMethodologyAdapterDependencies = WorkflowMethodologyAdapterDependencies;
+declare namespace index$d {
+  export { type index$d_IWorkflowMethodology as IWorkflowMethodology, type ValidationContext$1 as ValidationContext, index$d_WorkflowMethodologyAdapter as WorkflowMethodologyAdapter, type index$d_WorkflowMethodologyAdapterDependencies as WorkflowMethodologyAdapterDependencies };
 }
 
 /**
@@ -1896,6 +2127,7 @@ type BacklogAdapterDependencies = {
     planningMethodologyAdapter?: IWorkflowMethodology;
     identity: IdentityAdapter;
     eventBus: IEventStream;
+    configManager: ConfigManager;
     config?: BacklogAdapterConfig;
 };
 /**
@@ -1965,6 +2197,7 @@ declare class BacklogAdapter implements IBacklogAdapter {
     private workflowMethodologyAdapter;
     private identity;
     private eventBus;
+    private configManager;
     private config;
     constructor(dependencies: BacklogAdapterDependencies);
     /**
@@ -2085,7 +2318,7 @@ declare class BacklogAdapter implements IBacklogAdapter {
     /**
      * Updates a cycle with new payload
      */
-    updateCycle(cycleId: string, payload: Partial<CycleRecord>): Promise<CycleRecord>;
+    updateCycle(cycleId: string, payload: Partial<CycleRecord>, actorId?: string): Promise<CycleRecord>;
     /**
      * Creates bidirectional link between task and cycle
      */
@@ -2106,13 +2339,13 @@ declare class BacklogAdapter implements IBacklogAdapter {
     processChanges(_changes: unknown[]): Promise<ExecutionRecord[]>;
 }
 
-type index$b_BacklogAdapter = BacklogAdapter;
-declare const index$b_BacklogAdapter: typeof BacklogAdapter;
-type index$b_BacklogAdapterConfig = BacklogAdapterConfig;
-type index$b_BacklogAdapterDependencies = BacklogAdapterDependencies;
-type index$b_IBacklogAdapter = IBacklogAdapter;
-declare namespace index$b {
-  export { index$b_BacklogAdapter as BacklogAdapter, type index$b_BacklogAdapterConfig as BacklogAdapterConfig, type index$b_BacklogAdapterDependencies as BacklogAdapterDependencies, type index$b_IBacklogAdapter as IBacklogAdapter };
+type index$c_BacklogAdapter = BacklogAdapter;
+declare const index$c_BacklogAdapter: typeof BacklogAdapter;
+type index$c_BacklogAdapterConfig = BacklogAdapterConfig;
+type index$c_BacklogAdapterDependencies = BacklogAdapterDependencies;
+type index$c_IBacklogAdapter = IBacklogAdapter;
+declare namespace index$c {
+  export { index$c_BacklogAdapter as BacklogAdapter, type index$c_BacklogAdapterConfig as BacklogAdapterConfig, type index$c_BacklogAdapterDependencies as BacklogAdapterDependencies, type index$c_IBacklogAdapter as IBacklogAdapter };
 }
 
 /**
@@ -2471,138 +2704,723 @@ declare class FileIndexerAdapter implements IIndexerAdapter {
     private getTimestampFromId;
 }
 
-type index$a_AllRecords = AllRecords;
-type index$a_DerivedStateSets = DerivedStateSets;
-type index$a_DerivedStates = DerivedStates;
-type index$a_EnrichedTaskRecord = EnrichedTaskRecord;
-type index$a_FileIndexerAdapter = FileIndexerAdapter;
-declare const index$a_FileIndexerAdapter: typeof FileIndexerAdapter;
-type index$a_IIndexerAdapter = IIndexerAdapter;
-type index$a_IndexData = IndexData;
-type index$a_IndexGenerationReport = IndexGenerationReport;
-type index$a_IndexerAdapterDependencies = IndexerAdapterDependencies;
-type index$a_IntegrityError = IntegrityError;
-type index$a_IntegrityReport = IntegrityReport;
-type index$a_IntegrityWarning = IntegrityWarning;
-declare namespace index$a {
-  export { type index$a_AllRecords as AllRecords, type index$a_DerivedStateSets as DerivedStateSets, type index$a_DerivedStates as DerivedStates, type index$a_EnrichedTaskRecord as EnrichedTaskRecord, index$a_FileIndexerAdapter as FileIndexerAdapter, type index$a_IIndexerAdapter as IIndexerAdapter, type index$a_IndexData as IndexData, type index$a_IndexGenerationReport as IndexGenerationReport, type index$a_IndexerAdapterDependencies as IndexerAdapterDependencies, type index$a_IntegrityError as IntegrityError, type index$a_IntegrityReport as IntegrityReport, type index$a_IntegrityWarning as IntegrityWarning };
+type index$b_AllRecords = AllRecords;
+type index$b_DerivedStateSets = DerivedStateSets;
+type index$b_DerivedStates = DerivedStates;
+type index$b_EnrichedTaskRecord = EnrichedTaskRecord;
+type index$b_FileIndexerAdapter = FileIndexerAdapter;
+declare const index$b_FileIndexerAdapter: typeof FileIndexerAdapter;
+type index$b_IIndexerAdapter = IIndexerAdapter;
+type index$b_IndexData = IndexData;
+type index$b_IndexGenerationReport = IndexGenerationReport;
+type index$b_IndexerAdapterDependencies = IndexerAdapterDependencies;
+type index$b_IntegrityError = IntegrityError;
+type index$b_IntegrityReport = IntegrityReport;
+type index$b_IntegrityWarning = IntegrityWarning;
+declare namespace index$b {
+  export { type index$b_AllRecords as AllRecords, type index$b_DerivedStateSets as DerivedStateSets, type index$b_DerivedStates as DerivedStates, type index$b_EnrichedTaskRecord as EnrichedTaskRecord, index$b_FileIndexerAdapter as FileIndexerAdapter, type index$b_IIndexerAdapter as IIndexerAdapter, type index$b_IndexData as IndexData, type index$b_IndexGenerationReport as IndexGenerationReport, type index$b_IndexerAdapterDependencies as IndexerAdapterDependencies, type index$b_IntegrityError as IntegrityError, type index$b_IntegrityReport as IntegrityReport, type index$b_IntegrityWarning as IntegrityWarning };
 }
 
 /**
- * GitGovernance Configuration Types
- * Based on config_file.md blueprint
+ * Type Definitions for GitModule
+ *
+ * These interfaces define the contracts for Git operations,
+ * dependencies, and data structures used throughout the module.
  */
-interface GitGovConfig {
-    protocolVersion: string;
-    projectId: string;
-    projectName: string;
-    rootCycle: string;
-    blueprints?: {
-        root?: string;
-    };
-    state?: {
-        branch?: string;
-    };
-    cloud?: {
-        projectId?: string;
-        providerMappings?: Record<string, string>;
-    };
+/**
+ * Options for executing shell commands
+ */
+interface ExecOptions {
+    /** Working directory for the command */
+    cwd?: string;
+    /** Additional environment variables */
+    env?: Record<string, string>;
+    /** Timeout in milliseconds */
+    timeout?: number;
 }
 /**
- * GitGovernance Session State Types
- * Based on session_state.md blueprint
+ * Result of executing a shell command
  */
-interface ActorState {
-    activeTaskId?: string;
-    activeCycleId?: string;
-    lastSync?: string;
-    [key: string]: any;
+interface ExecResult {
+    /** Exit code (0 = success) */
+    exitCode: number;
+    /** Standard output */
+    stdout: string;
+    /** Standard error output */
+    stderr: string;
 }
-interface GitGovSession {
-    cloud?: {
-        sessionToken?: string;
-    };
-    lastSession?: {
-        actorId: string;
-        timestamp: string;
-    };
-    actorState?: Record<string, ActorState>;
+/**
+ * Dependencies required by GitModule
+ *
+ * This module uses dependency injection to allow testing with mocks
+ * and support different execution environments.
+ */
+interface GitModuleDependencies {
+    /** Path to the Git repository root (optional, auto-detected if not provided) */
+    repoRoot?: string;
+    /** Function to execute shell commands (required) */
+    execCommand: (command: string, args: string[], options?: ExecOptions) => Promise<ExecResult>;
 }
 /**
- * Configuration Manager Class
- * Provides typed access to GitGovernance configuration and session state
+ * Options for retrieving commit history
  */
-declare class ConfigManager {
-    private configPath;
-    private sessionPath;
-    constructor(projectRootPath?: string);
+interface GetCommitHistoryOptions {
+    /** Maximum number of commits to return */
+    maxCount?: number;
+    /** Path filter (e.g., ".gitgov/") */
+    pathFilter?: string;
+    /** Output format (default: "json") */
+    format?: 'json' | 'text';
+}
+/**
+ * Information about a commit in the history
+ */
+interface CommitInfo {
+    /** Commit hash */
+    hash: string;
+    /** Commit message */
+    message: string;
+    /** Commit author (name <email>) */
+    author: string;
+    /** Commit date (ISO 8601) */
+    date: string;
+    /** List of modified files (optional) */
+    files?: string[];
+}
+/**
+ * Information about a changed file
+ */
+interface ChangedFile {
+    /** Change status: A (Added), M (Modified), D (Deleted) */
+    status: 'A' | 'M' | 'D';
+    /** File path relative to repository root */
+    file: string;
+}
+/**
+ * Author information for commits
+ */
+interface CommitAuthor {
+    /** Author name */
+    name: string;
+    /** Author email */
+    email: string;
+}
+
+/**
+ * GitModule - Low-level Git Operations
+ *
+ * This module provides a business-agnostic abstraction layer for interacting
+ * with the local Git repository. It exposes semantic methods instead of raw
+ * Git commands, with comprehensive error handling and type safety.
+ *
+ * @module git_module
+ */
+
+/**
+ * GitModule class providing low-level Git operations
+ *
+ * All operations are async and use dependency injection for testability.
+ * Errors are transformed into typed exceptions for better handling.
+ */
+declare class GitModule {
+    private repoRoot;
+    private execCommand;
     /**
-     * Load GitGovernance configuration
+     * Creates a new GitModule instance
+     *
+     * @param dependencies - Required dependencies (execCommand) and optional config (repoRoot)
+     * @throws Error if execCommand is not provided
      */
-    loadConfig(): Promise<GitGovConfig | null>;
+    constructor(dependencies: GitModuleDependencies);
     /**
-     * Load GitGovernance session state
+     * Ensures that repoRoot is set, auto-detecting it if necessary
+     *
+     * @returns Path to repository root
+     * @throws GitCommandError if not in a Git repository
      */
-    loadSession(): Promise<GitGovSession | null>;
+    private ensureRepoRoot;
     /**
-     * Get root cycle from configuration
+     * Executes a Git command with standardized error handling
+     *
+     * @param args - Git command arguments
+     * @param options - Execution options
+     * @returns Command result
+     * @throws GitCommandError if command fails
      */
-    getRootCycle(): Promise<string | null>;
+    private execGit;
     /**
-     * Get project information from configuration
+     * Initializes a new Git repository in the current directory
+     *
+     * Creates the `.git/` directory structure and sets up initial configuration.
+     * Useful for testing and for commands that require a fresh repository.
+     *
+     * @throws GitCommandError if directory is already a Git repository
+     *
+     * @example
+     * await gitModule.init();
+     * // Repository initialized with default branch (main or master)
      */
-    getProjectInfo(): Promise<{
-        id: string;
-        name: string;
-    } | null>;
+    init(): Promise<void>;
     /**
-     * Get actor state for a specific actor
+     * Returns the absolute path to the current Git repository root
+     *
+     * @returns Repository root path
+     * @throws GitCommandError if not in a Git repository
+     *
+     * @example
+     * const repoRoot = await gitModule.getRepoRoot();
+     * // => "/home/user/my-project"
      */
-    getActorState(actorId: string): Promise<ActorState | null>;
+    getRepoRoot(): Promise<string>;
     /**
-     * Update actor state for a specific actor
+     * Returns the name of the current branch (HEAD)
+     *
+     * @returns Current branch name
+     * @throws GitCommandError if in detached HEAD state or other error
+     *
+     * @example
+     * const branch = await gitModule.getCurrentBranch();
+     * // => "main"
      */
-    updateActorState(actorId: string, state: Partial<ActorState>): Promise<void>;
+    getCurrentBranch(): Promise<string>;
     /**
-     * Get cloud session token
+     * Get commit hash for a given reference (branch, tag, HEAD, etc.)
+     *
+     * Used by test helpers and sync operations to get commit SHAs.
+     * Returns the full 40-character SHA-1 hash of the commit.
+     *
+     * @param ref Git reference (default: "HEAD"). Can be:
+     *            - "HEAD" for current commit
+     *            - Branch name (e.g., "main", "gitgov-state")
+     *            - Tag name (e.g., "v1.0.0")
+     *            - Commit hash (returns the same hash)
+     *            - Relative refs (e.g., "HEAD~1", "main^")
+     * @returns Commit SHA hash (full 40-character hash)
+     * @throws GitCommandError if ref does not exist
+     *
+     * @example
+     * const headHash = await git.getCommitHash("HEAD");
+     * // => "a1b2c3d4e5f6..."
+     *
+     * const mainHash = await git.getCommitHash("main");
+     * // => "f6e5d4c3b2a1..."
+     *
+     * const parentHash = await git.getCommitHash("HEAD~1");
+     * // => "9876543210ab..."
      */
-    getCloudSessionToken(): Promise<string | null>;
+    getCommitHash(ref?: string): Promise<string>;
     /**
-     * Finds the project root by searching upwards for a .git directory.
-     * Caches the result for subsequent calls.
-     * @param startPath The path to start searching from. Defaults to the current working directory.
-     * @returns The absolute path to the project root, or null if not found.
+     * Set a Git configuration value.
+     * Used for configuring repository settings like user.name, core.editor, etc.
+     *
+     * [EARS-51, EARS-52]
+     *
+     * @param key - Configuration key (e.g., "user.name", "core.editor")
+     * @param value - Configuration value
+     * @param scope - Configuration scope: "local" (default), "global", or "system"
+     * @throws GitCommandError if configuration fails
+     *
+     * @example
+     * ```typescript
+     * // Set local config (repository-specific)
+     * await git.setConfig('core.editor', 'vim');
+     *
+     * // Set global config (user-wide)
+     * await git.setConfig('user.name', 'John Doe', 'global');
+     *
+     * // Set system config (machine-wide, requires permissions)
+     * await git.setConfig('credential.helper', 'cache', 'system');
+     * ```
      */
-    static findProjectRoot(startPath?: string): string | null;
+    setConfig(key: string, value: string, scope?: 'local' | 'global' | 'system'): Promise<void>;
     /**
-     * Finds the appropriate project root by searching upwards.
-     * First looks for .gitgov (initialized project), then .git (for init).
-     * @param startPath The path to start searching from. Defaults to the current working directory.
-     * @returns The absolute path to the project root, or null if not found.
+     * Finds the most recent common ancestor between two branches
+     *
+     * @param branchA - First branch name
+     * @param branchB - Second branch name
+     * @returns Commit hash of the merge base
+     * @throws BranchNotFoundError if either branch does not exist
+     * @throws GitCommandError if operation fails
+     *
+     * @example
+     * const mergeBase = await gitModule.getMergeBase("main", "feature");
+     * // => "a1b2c3d4e5f6..."
      */
-    static findGitgovRoot(startPath?: string): string | null;
+    getMergeBase(branchA: string, branchB: string): Promise<string>;
     /**
-     * Gets the .gitgov directory path from project root
+     * Returns a list of files changed between two commits
+     *
+     * @param fromCommit - Source commit or reference
+     * @param toCommit - Target commit or reference
+     * @param pathFilter - Optional path filter (e.g., ".gitgov/")
+     * @returns Array of changed files with their status
+     * @throws GitCommandError if operation fails
+     *
+     * @example
+     * const changes = await gitModule.getChangedFiles("HEAD~1", "HEAD", ".gitgov/");
+     * // => [{ status: "M", file: ".gitgov/tasks/123.json" }]
      */
-    static getGitgovPath(): string;
+    getChangedFiles(fromCommit: string, toCommit: string, pathFilter: string): Promise<ChangedFile[]>;
     /**
-     * Checks if current directory is a GitGovernance project
+     * Get list of staged files (in staging area / index)
+     *
+     * Used during conflict resolution to identify which files the user resolved and staged.
+     *
+     * @returns Array of file paths that are currently staged
+     * @throws GitCommandError if operation fails
+     *
+     * @example
+     * // After user resolves conflict and does: git add .gitgov/tasks/123.json
+     * const staged = await gitModule.getStagedFiles();
+     * // => [".gitgov/tasks/123.json"]
      */
-    static isGitgovProject(): boolean;
+    getStagedFiles(): Promise<string[]>;
+    /**
+     * Retrieves the content of a file at a specific point in history
+     *
+     * @param commitHash - Commit hash
+     * @param filePath - File path relative to repository root
+     * @returns File content as string
+     * @throws FileNotFoundError if file doesn't exist in that commit
+     * @throws GitCommandError if operation fails
+     *
+     * @example
+     * const content = await gitModule.getFileContent("abc123", ".gitgov/config.json");
+     * // => '{"version": "1.0.0"}'
+     */
+    getFileContent(commitHash: string, filePath: string): Promise<string>;
+    /**
+     * Retrieves the commit history for a branch
+     *
+     * @param branch - Branch name
+     * @param options - Filtering and formatting options
+     * @returns Array of commits ordered from newest to oldest
+     * @throws GitCommandError if operation fails
+     *
+     * @example
+     * const history = await gitModule.getCommitHistory("main", { maxCount: 10 });
+     * // => [{ hash: "abc123", message: "Initial commit", author: "User <email>", date: "2025-01-01T00:00:00Z" }]
+     */
+    getCommitHistory(branch: string, options?: GetCommitHistoryOptions): Promise<CommitInfo[]>;
+    /**
+     * Retrieves commit history in a specific range
+     *
+     * @param fromHash - Starting commit hash (exclusive)
+     * @param toHash - Ending commit hash (inclusive)
+     * @param options - Filtering and formatting options
+     * @returns Array of commits in the specified range
+     * @throws GitCommandError if either commit doesn't exist
+     *
+     * @example
+     * const commits = await gitModule.getCommitHistoryRange("abc123", "def456");
+     * // => [{ hash: "def456", ... }, { hash: "cba321", ... }]
+     */
+    getCommitHistoryRange(fromHash: string, toHash: string, options?: GetCommitHistoryOptions): Promise<CommitInfo[]>;
+    /**
+     * Retrieves the full commit message for a specific commit
+     *
+     * @param commitHash - Commit hash
+     * @returns Full commit message as string
+     * @throws GitCommandError if commit doesn't exist
+     *
+     * @example
+     * const message = await gitModule.getCommitMessage("abc123");
+     * // => "feat: add new feature\n\nDetailed description..."
+     */
+    getCommitMessage(commitHash: string): Promise<string>;
+    /**
+     * Checks if there are uncommitted changes in the working directory
+     *
+     * @param pathFilter - Optional path filter (e.g., ".gitgov/")
+     * @returns true if there are uncommitted changes, false otherwise
+     * @throws GitCommandError if operation fails
+     *
+     * @example
+     * const hasChanges = await gitModule.hasUncommittedChanges(".gitgov/");
+     * // => true
+     */
+    hasUncommittedChanges(pathFilter?: string): Promise<boolean>;
+    /**
+     * Checks if a rebase operation is currently in progress
+     *
+     * @returns true if rebase is in progress, false otherwise
+     *
+     * @example
+     * const inRebase = await gitModule.isRebaseInProgress();
+     * // => false
+     */
+    isRebaseInProgress(): Promise<boolean>;
+    /**
+     * Checks if a branch exists locally
+     *
+     * @param branchName - Branch name to check
+     * @returns true if branch exists, false otherwise
+     *
+     * @example
+     * const exists = await gitModule.branchExists("feature-branch");
+     * // => true
+     */
+    branchExists(branchName: string): Promise<boolean>;
+    /**
+     * Lists all remote branches for a given remote
+     *
+     * @param remoteName - Name of the remote (e.g., "origin")
+     * @returns Array of remote branch names without the remote prefix
+     * @throws GitCommandError if operation fails
+     *
+     * @example
+     * const branches = await gitModule.listRemoteBranches("origin");
+     * // => ["main", "develop", "gitgov-state"]
+     *
+     * @note This method only returns the branch names, not the full "origin/branch" format
+     */
+    listRemoteBranches(remoteName: string): Promise<string[]>;
+    /**
+     * Checks if a remote is configured in the git repository.
+     *
+     * @param remoteName - Name of the remote to check (e.g., "origin")
+     * @returns true if the remote is configured, false otherwise
+     *
+     * @example
+     * const hasOrigin = await gitModule.isRemoteConfigured("origin");
+     * // => true
+     */
+    isRemoteConfigured(remoteName: string): Promise<boolean>;
+    /**
+     * Retrieves the tracking remote for a branch
+     *
+     * @param branchName - Branch name
+     * @returns Remote name or null if not configured
+     * @throws BranchNotFoundError if branch doesn't exist
+     *
+     * @example
+     * const remote = await gitModule.getBranchRemote("main");
+     * // => "origin"
+     */
+    getBranchRemote(branchName: string): Promise<string | null>;
+    /**
+     * Retrieves the list of conflicted files during a rebase or merge
+     *
+     * @returns Array of file paths in conflict
+     * @throws GitCommandError if no rebase/merge in progress
+     *
+     * @example
+     * const conflicts = await gitModule.getConflictedFiles();
+     * // => [".gitgov/tasks/123.json", ".gitgov/tasks/456.json"]
+     */
+    getConflictedFiles(): Promise<string[]>;
+    /**
+     * Switches to the specified branch
+     *
+     * @param branchName - Branch name to checkout
+     * @throws BranchNotFoundError if branch doesn't exist
+     * @throws GitCommandError if operation fails
+     *
+     * @example
+     * await gitModule.checkoutBranch("feature-branch");
+     */
+    checkoutBranch(branchName: string): Promise<void>;
+    /**
+     * Stash uncommitted changes
+     *
+     * @param message - Optional message for the stash
+     * @returns Stash hash if changes were stashed, null if nothing to stash
+     */
+    stash(message?: string): Promise<string | null>;
+    /**
+     * Pop the most recent stash
+     *
+     * @returns true if stash was popped successfully, false if no stash exists
+     */
+    stashPop(): Promise<boolean>;
+    /**
+     * Drop a specific stash or the most recent one
+     *
+     * @param stashHash - Optional stash hash to drop, defaults to most recent
+     */
+    stashDrop(stashHash?: string): Promise<void>;
+    /**
+     * Creates an orphan branch (no history) and switches to it
+     *
+     * @param branchName - Orphan branch name to create
+     * @throws GitCommandError if branch already exists or operation fails
+     *
+     * @example
+     * await gitModule.checkoutOrphanBranch("gitgov-state");
+     */
+    checkoutOrphanBranch(branchName: string): Promise<void>;
+    /**
+     * Fetches the latest changes from a remote repository
+     *
+     * @param remote - Remote name (e.g., "origin")
+     * @throws GitCommandError if operation fails
+     *
+     * @example
+     * await gitModule.fetch("origin");
+     */
+    fetch(remote: string): Promise<void>;
+    /**
+     * Pulls and merges a remote branch
+     *
+     * @param remote - Remote name
+     * @param branchName - Branch name
+     * @throws MergeConflictError if merge conflicts occur
+     * @throws GitCommandError if operation fails
+     *
+     * @example
+     * await gitModule.pull("origin", "main");
+     */
+    pull(remote: string, branchName: string): Promise<void>;
+    /**
+     * Pulls and rebases a remote branch
+     *
+     * @param remote - Remote name
+     * @param branchName - Branch name
+     * @throws RebaseConflictError if rebase conflicts occur
+     * @throws GitCommandError if operation fails
+     *
+     * @example
+     * await gitModule.pullRebase("origin", "main");
+     */
+    pullRebase(remote: string, branchName: string): Promise<void>;
+    /**
+     * Resets the current branch to a specific commit, discarding all local changes
+     *
+     * @param target - Commit hash or branch name
+     * @throws GitCommandError if operation fails
+     *
+     * @example
+     * await gitModule.resetHard("HEAD~1");
+     */
+    resetHard(target: string): Promise<void>;
+    /**
+     * Checks out specific files from another branch into the current staging area
+     *
+     * @param sourceBranch - Source branch name
+     * @param filePaths - Array of file paths to checkout
+     * @throws BranchNotFoundError if source branch doesn't exist
+     * @throws GitCommandError if operation fails
+     *
+     * @example
+     * await gitModule.checkoutFilesFromBranch("main", [".gitgov/tasks/123.json"]);
+     */
+    checkoutFilesFromBranch(sourceBranch: string, filePaths: string[]): Promise<void>;
+    /**
+     * Adds files to the staging area
+     *
+     * @param filePaths - Array of file paths to add
+     * @param options - Optional settings (force: add ignored files)
+     * @throws GitCommandError if operation fails
+     *
+     * @example
+     * await gitModule.add([".gitgov/tasks/123.json"]);
+     * await gitModule.add([".gitgov"], { force: true }); // Add ignored files
+     */
+    add(filePaths: string[], options?: {
+        force?: boolean;
+    }): Promise<void>;
+    /**
+     * Removes files from both working directory and staging area
+     *
+     * @param filePaths - Array of file paths to remove
+     * @throws GitCommandError if operation fails
+     *
+     * @example
+     * await gitModule.rm([".gitgov/tasks/123.json"]);
+     */
+    rm(filePaths: string[]): Promise<void>;
+    /**
+     * Creates a new commit with staged files
+     *
+     * @param message - Commit message
+     * @param author - Optional commit author
+     * @returns Commit hash of the created commit
+     * @throws GitCommandError if operation fails
+     *
+     * @example
+     * const hash = await gitModule.commit("feat: add new task");
+     * // => "abc123def456..."
+     */
+    commit(message: string, author?: CommitAuthor): Promise<string>;
+    /**
+     * Creates an empty commit (no changes required)
+     *
+     * @param message - Commit message
+     * @param author - Optional commit author
+     * @returns Commit hash of the created commit
+     * @throws GitCommandError if operation fails
+     *
+     * @example
+     * const hash = await gitModule.commitAllowEmpty("chore: initialize state branch");
+     * // => "abc123def456..."
+     */
+    commitAllowEmpty(message: string, author?: CommitAuthor): Promise<string>;
+    /**
+     * Pushes a local branch to a remote repository
+     *
+     * @param remote - Remote name
+     * @param branchName - Branch name
+     * @throws GitCommandError if operation fails
+     *
+     * @example
+     * await gitModule.push("origin", "main");
+     */
+    push(remote: string, branchName: string): Promise<void>;
+    /**
+     * Pushes a local branch to a remote repository and sets up tracking
+     *
+     * @param remote - Remote name
+     * @param branchName - Branch name
+     * @throws GitCommandError if operation fails
+     *
+     * @example
+     * await gitModule.pushWithUpstream("origin", "feature-branch");
+     */
+    pushWithUpstream(remote: string, branchName: string): Promise<void>;
+    /**
+     * Configures tracking for a local branch with a remote branch
+     *
+     * @param branchName - Local branch name
+     * @param remote - Remote name
+     * @param remoteBranch - Remote branch name
+     * @throws BranchNotFoundError if local branch doesn't exist
+     * @throws GitCommandError if operation fails
+     *
+     * @example
+     * await gitModule.setUpstream("feature-branch", "origin", "feature-branch");
+     */
+    setUpstream(branchName: string, remote: string, remoteBranch: string): Promise<void>;
+    /**
+     * Continues a rebase after resolving conflicts
+     *
+     * @returns Commit hash of the rebased commit
+     * @throws RebaseNotInProgressError if no rebase is in progress
+     * @throws GitCommandError if operation fails
+     *
+     * @example
+     * const hash = await gitModule.rebaseContinue();
+     * // => "abc123def456..."
+     */
+    rebaseContinue(): Promise<string>;
+    /**
+     * Aborts an ongoing rebase
+     *
+     * @throws RebaseNotInProgressError if no rebase is in progress
+     * @throws GitCommandError if operation fails
+     *
+     * @example
+     * await gitModule.rebaseAbort();
+     */
+    rebaseAbort(): Promise<void>;
+    /**
+     * Creates a new branch and switches to it (git checkout -b)
+     *
+     * @param branchName - Name of the branch to create
+     * @param startPoint - Optional starting point (commit hash or branch name)
+     * @throws GitCommandError if branch already exists or operation fails
+     * @throws BranchAlreadyExistsError if the branch already exists locally
+     */
+    createBranch(branchName: string, startPoint?: string): Promise<void>;
+    /**
+     * Rebases current branch onto target branch (git rebase)
+     *
+     * @param targetBranch - Branch to rebase onto
+     * @throws GitCommandError if rebase fails
+     * @throws RebaseConflictError if conflicts are detected during rebase
+     */
+    rebase(targetBranch: string): Promise<void>;
+}
+
+/**
+ * Custom Error Classes for GitModule
+ *
+ * These errors provide typed exceptions for better error handling
+ * and diagnostics in the Git module operations.
+ */
+/**
+ * Base error class for all Git-related errors
+ */
+declare class GitError extends Error {
+    constructor(message: string);
+}
+/**
+ * Error thrown when a Git command fails
+ */
+declare class GitCommandError extends GitError {
+    readonly stderr: string;
+    readonly stdout?: string | undefined;
+    readonly command?: string | undefined;
+    constructor(message: string, stderr?: string, command?: string | undefined, stdout?: string);
+}
+/**
+ * Error thrown when a branch does not exist
+ */
+declare class BranchNotFoundError extends GitError {
+    readonly branchName: string;
+    constructor(branchName: string);
+}
+/**
+ * Error thrown when a file does not exist in a commit
+ */
+declare class FileNotFoundError extends GitError {
+    readonly filePath: string;
+    readonly commitHash: string;
+    constructor(filePath: string, commitHash: string);
+}
+/**
+ * Error thrown when a merge conflict occurs
+ */
+declare class MergeConflictError extends GitError {
+    readonly conflictedFiles: string[];
+    constructor(conflictedFiles: string[]);
 }
 /**
- * Create a ConfigManager instance for the current project
+ * Error thrown when a rebase conflict occurs
  */
-declare function createConfigManager(projectRoot?: string): ConfigManager;
+declare class RebaseConflictError extends GitError {
+    readonly conflictedFiles: string[];
+    constructor(conflictedFiles: string[]);
+}
+/**
+ * Error thrown when trying to continue/abort a rebase that is not in progress
+ */
+declare class RebaseNotInProgressError extends GitError {
+    constructor();
+}
 
-type index$9_ActorState = ActorState;
-type index$9_ConfigManager = ConfigManager;
-declare const index$9_ConfigManager: typeof ConfigManager;
-type index$9_GitGovConfig = GitGovConfig;
-type index$9_GitGovSession = GitGovSession;
-declare const index$9_createConfigManager: typeof createConfigManager;
-declare namespace index$9 {
-  export { type index$9_ActorState as ActorState, index$9_ConfigManager as ConfigManager, type index$9_GitGovConfig as GitGovConfig, type index$9_GitGovSession as GitGovSession, index$9_createConfigManager as createConfigManager };
+/**
+ * GitModule - Low-level Git Operations
+ *
+ * This module provides a business-agnostic abstraction layer for Git operations.
+ *
+ * @module git
+ */
+
+type index$a_BranchNotFoundError = BranchNotFoundError;
+declare const index$a_BranchNotFoundError: typeof BranchNotFoundError;
+type index$a_ChangedFile = ChangedFile;
+type index$a_CommitAuthor = CommitAuthor;
+type index$a_CommitInfo = CommitInfo;
+type index$a_ExecOptions = ExecOptions;
+type index$a_ExecResult = ExecResult;
+type index$a_FileNotFoundError = FileNotFoundError;
+declare const index$a_FileNotFoundError: typeof FileNotFoundError;
+type index$a_GetCommitHistoryOptions = GetCommitHistoryOptions;
+type index$a_GitCommandError = GitCommandError;
+declare const index$a_GitCommandError: typeof GitCommandError;
+type index$a_GitError = GitError;
+declare const index$a_GitError: typeof GitError;
+type index$a_GitModule = GitModule;
+declare const index$a_GitModule: typeof GitModule;
+type index$a_GitModuleDependencies = GitModuleDependencies;
+type index$a_MergeConflictError = MergeConflictError;
+declare const index$a_MergeConflictError: typeof MergeConflictError;
+type index$a_RebaseConflictError = RebaseConflictError;
+declare const index$a_RebaseConflictError: typeof RebaseConflictError;
+type index$a_RebaseNotInProgressError = RebaseNotInProgressError;
+declare const index$a_RebaseNotInProgressError: typeof RebaseNotInProgressError;
+declare namespace index$a {
+  export { index$a_BranchNotFoundError as BranchNotFoundError, type index$a_ChangedFile as ChangedFile, type index$a_CommitAuthor as CommitAuthor, type index$a_CommitInfo as CommitInfo, type index$a_ExecOptions as ExecOptions, type index$a_ExecResult as ExecResult, index$a_FileNotFoundError as FileNotFoundError, type index$a_GetCommitHistoryOptions as GetCommitHistoryOptions, index$a_GitCommandError as GitCommandError, index$a_GitError as GitError, index$a_GitModule as GitModule, type index$a_GitModuleDependencies as GitModuleDependencies, index$a_MergeConflictError as MergeConflictError, index$a_RebaseConflictError as RebaseConflictError, index$a_RebaseNotInProgressError as RebaseNotInProgressError };
 }
 
 /**
@@ -2611,19 +3429,8 @@ declare namespace index$9 {
 interface ProjectAdapterDependencies {
     identityAdapter: IdentityAdapter;
     backlogAdapter: BacklogAdapter;
-    workflowMethodologyAdapter: WorkflowMethodologyAdapter;
+    gitModule: GitModule;
     configManager: ConfigManager;
-    taskStore: RecordStore<TaskRecord>;
-    cycleStore: RecordStore<CycleRecord>;
-    eventBus?: IEventStream;
-    platformApi?: IPlatformApi;
-    userManagement?: IUserManagement;
-}
-interface IPlatformApi {
-    getProjectInfo(projectId: string): Promise<ProjectInfo>;
-}
-interface IUserManagement {
-    addUserToProject(projectId: string, userId: string, role: string): Promise<void>;
 }
 type ProjectInitOptions = {
     name: string;
@@ -2718,10 +3525,11 @@ interface IProjectAdapter {
 declare class ProjectAdapter implements IProjectAdapter {
     private identityAdapter;
     private backlogAdapter;
+    private gitModule;
     private configManager;
     constructor(dependencies: ProjectAdapterDependencies);
     /**
-     * [EARS-1] Initializes complete GitGovernance project with 3-adapter orchestration and trust root Ed25519
+     * [EARS-1] Initializes complete GitGovernance project with 4-module orchestration (Identity, Backlog, WorkflowMethodology, SyncModule) and trust root Ed25519
      */
     initializeProject(options: ProjectInitOptions): Promise<ProjectInitResult>;
     /**
@@ -2756,8 +3564,66 @@ declare class ProjectAdapter implements IProjectAdapter {
     private setupGitIntegration;
 }
 
+type index$9_EnvironmentValidation = EnvironmentValidation;
+type index$9_IProjectAdapter = IProjectAdapter;
+type index$9_ProjectAdapter = ProjectAdapter;
+declare const index$9_ProjectAdapter: typeof ProjectAdapter;
+type index$9_ProjectAdapterDependencies = ProjectAdapterDependencies;
+type index$9_ProjectContext = ProjectContext;
+type index$9_ProjectInfo = ProjectInfo;
+type index$9_ProjectInitOptions = ProjectInitOptions;
+type index$9_ProjectInitResult = ProjectInitResult;
+type index$9_ProjectReport = ProjectReport;
+type index$9_TemplateProcessingResult = TemplateProcessingResult;
+declare namespace index$9 {
+  export { type index$9_EnvironmentValidation as EnvironmentValidation, type index$9_IProjectAdapter as IProjectAdapter, index$9_ProjectAdapter as ProjectAdapter, type index$9_ProjectAdapterDependencies as ProjectAdapterDependencies, type index$9_ProjectContext as ProjectContext, type index$9_ProjectInfo as ProjectInfo, type index$9_ProjectInitOptions as ProjectInitOptions, type index$9_ProjectInitResult as ProjectInitResult, type index$9_ProjectReport as ProjectReport, type index$9_TemplateProcessingResult as TemplateProcessingResult };
+}
+
+type index$8_AllRecords = AllRecords;
+type index$8_BacklogAdapter = BacklogAdapter;
+declare const index$8_BacklogAdapter: typeof BacklogAdapter;
+type index$8_BacklogAdapterConfig = BacklogAdapterConfig;
+type index$8_BacklogAdapterDependencies = BacklogAdapterDependencies;
+type index$8_ChangelogAdapter = ChangelogAdapter;
+declare const index$8_ChangelogAdapter: typeof ChangelogAdapter;
+type index$8_ChangelogAdapterDependencies = ChangelogAdapterDependencies;
+type index$8_ChangelogListOptions = ChangelogListOptions;
+type index$8_CollaborationMetrics = CollaborationMetrics;
+type index$8_DerivedStateSets = DerivedStateSets;
+type index$8_DerivedStates = DerivedStates;
+type index$8_EnrichedTaskRecord = EnrichedTaskRecord;
 type index$8_EnvironmentValidation = EnvironmentValidation;
+type index$8_ExecutionAdapter = ExecutionAdapter;
+declare const index$8_ExecutionAdapter: typeof ExecutionAdapter;
+type index$8_ExecutionAdapterDependencies = ExecutionAdapterDependencies;
+type index$8_FeedbackAdapter = FeedbackAdapter;
+declare const index$8_FeedbackAdapter: typeof FeedbackAdapter;
+type index$8_FeedbackAdapterDependencies = FeedbackAdapterDependencies;
+type index$8_FeedbackThread = FeedbackThread;
+type index$8_FileIndexerAdapter = FileIndexerAdapter;
+declare const index$8_FileIndexerAdapter: typeof FileIndexerAdapter;
+type index$8_IBacklogAdapter = IBacklogAdapter;
+type index$8_IChangelogAdapter = IChangelogAdapter;
+type index$8_IExecutionAdapter = IExecutionAdapter;
+type index$8_IFeedbackAdapter = IFeedbackAdapter;
+type index$8_IIdentityAdapter = IIdentityAdapter;
+type index$8_IIndexerAdapter = IIndexerAdapter;
+type index$8_IMetricsAdapter = IMetricsAdapter;
 type index$8_IProjectAdapter = IProjectAdapter;
+type index$8_IWorkflowMethodology = IWorkflowMethodology;
+type index$8_IdentityAdapter = IdentityAdapter;
+declare const index$8_IdentityAdapter: typeof IdentityAdapter;
+type index$8_IdentityAdapterDependencies = IdentityAdapterDependencies;
+type index$8_IndexData = IndexData;
+type index$8_IndexGenerationReport = IndexGenerationReport;
+type index$8_IndexerAdapterDependencies = IndexerAdapterDependencies;
+type index$8_IntegrityError = IntegrityError;
+type index$8_IntegrityReport = IntegrityReport;
+type index$8_IntegrityWarning = IntegrityWarning;
+type index$8_MetricsAdapter = MetricsAdapter;
+declare const index$8_MetricsAdapter: typeof MetricsAdapter;
+type index$8_MetricsAdapterDependencies = MetricsAdapterDependencies;
+type index$8_ProductivityMetrics = ProductivityMetrics;
 type index$8_ProjectAdapter = ProjectAdapter;
 declare const index$8_ProjectAdapter: typeof ProjectAdapter;
 type index$8_ProjectAdapterDependencies = ProjectAdapterDependencies;
@@ -2766,72 +3632,14 @@ type index$8_ProjectInfo = ProjectInfo;
 type index$8_ProjectInitOptions = ProjectInitOptions;
 type index$8_ProjectInitResult = ProjectInitResult;
 type index$8_ProjectReport = ProjectReport;
+type index$8_SystemStatus = SystemStatus;
+type index$8_TaskHealthReport = TaskHealthReport;
 type index$8_TemplateProcessingResult = TemplateProcessingResult;
+type index$8_WorkflowMethodologyAdapter = WorkflowMethodologyAdapter;
+declare const index$8_WorkflowMethodologyAdapter: typeof WorkflowMethodologyAdapter;
+type index$8_WorkflowMethodologyAdapterDependencies = WorkflowMethodologyAdapterDependencies;
 declare namespace index$8 {
-  export { type index$8_EnvironmentValidation as EnvironmentValidation, type index$8_IProjectAdapter as IProjectAdapter, index$8_ProjectAdapter as ProjectAdapter, type index$8_ProjectAdapterDependencies as ProjectAdapterDependencies, type index$8_ProjectContext as ProjectContext, type index$8_ProjectInfo as ProjectInfo, type index$8_ProjectInitOptions as ProjectInitOptions, type index$8_ProjectInitResult as ProjectInitResult, type index$8_ProjectReport as ProjectReport, type index$8_TemplateProcessingResult as TemplateProcessingResult };
-}
-
-type index$7_AllRecords = AllRecords;
-type index$7_BacklogAdapter = BacklogAdapter;
-declare const index$7_BacklogAdapter: typeof BacklogAdapter;
-type index$7_BacklogAdapterConfig = BacklogAdapterConfig;
-type index$7_BacklogAdapterDependencies = BacklogAdapterDependencies;
-type index$7_ChangelogAdapter = ChangelogAdapter;
-declare const index$7_ChangelogAdapter: typeof ChangelogAdapter;
-type index$7_ChangelogAdapterDependencies = ChangelogAdapterDependencies;
-type index$7_ChangelogListOptions = ChangelogListOptions;
-type index$7_CollaborationMetrics = CollaborationMetrics;
-type index$7_DerivedStateSets = DerivedStateSets;
-type index$7_DerivedStates = DerivedStates;
-type index$7_EnrichedTaskRecord = EnrichedTaskRecord;
-type index$7_EnvironmentValidation = EnvironmentValidation;
-type index$7_ExecutionAdapter = ExecutionAdapter;
-declare const index$7_ExecutionAdapter: typeof ExecutionAdapter;
-type index$7_ExecutionAdapterDependencies = ExecutionAdapterDependencies;
-type index$7_FeedbackAdapter = FeedbackAdapter;
-declare const index$7_FeedbackAdapter: typeof FeedbackAdapter;
-type index$7_FeedbackAdapterDependencies = FeedbackAdapterDependencies;
-type index$7_FeedbackThread = FeedbackThread;
-type index$7_FileIndexerAdapter = FileIndexerAdapter;
-declare const index$7_FileIndexerAdapter: typeof FileIndexerAdapter;
-type index$7_IBacklogAdapter = IBacklogAdapter;
-type index$7_IChangelogAdapter = IChangelogAdapter;
-type index$7_IExecutionAdapter = IExecutionAdapter;
-type index$7_IFeedbackAdapter = IFeedbackAdapter;
-type index$7_IIdentityAdapter = IIdentityAdapter;
-type index$7_IIndexerAdapter = IIndexerAdapter;
-type index$7_IMetricsAdapter = IMetricsAdapter;
-type index$7_IProjectAdapter = IProjectAdapter;
-type index$7_IWorkflowMethodology = IWorkflowMethodology;
-type index$7_IdentityAdapter = IdentityAdapter;
-declare const index$7_IdentityAdapter: typeof IdentityAdapter;
-type index$7_IdentityAdapterDependencies = IdentityAdapterDependencies;
-type index$7_IndexData = IndexData;
-type index$7_IndexGenerationReport = IndexGenerationReport;
-type index$7_IndexerAdapterDependencies = IndexerAdapterDependencies;
-type index$7_IntegrityError = IntegrityError;
-type index$7_IntegrityReport = IntegrityReport;
-type index$7_IntegrityWarning = IntegrityWarning;
-type index$7_MetricsAdapter = MetricsAdapter;
-declare const index$7_MetricsAdapter: typeof MetricsAdapter;
-type index$7_MetricsAdapterDependencies = MetricsAdapterDependencies;
-type index$7_ProductivityMetrics = ProductivityMetrics;
-type index$7_ProjectAdapter = ProjectAdapter;
-declare const index$7_ProjectAdapter: typeof ProjectAdapter;
-type index$7_ProjectAdapterDependencies = ProjectAdapterDependencies;
-type index$7_ProjectContext = ProjectContext;
-type index$7_ProjectInfo = ProjectInfo;
-type index$7_ProjectInitOptions = ProjectInitOptions;
-type index$7_ProjectInitResult = ProjectInitResult;
-type index$7_ProjectReport = ProjectReport;
-type index$7_SystemStatus = SystemStatus;
-type index$7_TaskHealthReport = TaskHealthReport;
-type index$7_TemplateProcessingResult = TemplateProcessingResult;
-type index$7_WorkflowMethodologyAdapter = WorkflowMethodologyAdapter;
-declare const index$7_WorkflowMethodologyAdapter: typeof WorkflowMethodologyAdapter;
-type index$7_WorkflowMethodologyAdapterDependencies = WorkflowMethodologyAdapterDependencies;
-declare namespace index$7 {
-  export { type index$7_AllRecords as AllRecords, index$7_BacklogAdapter as BacklogAdapter, type index$7_BacklogAdapterConfig as BacklogAdapterConfig, type index$7_BacklogAdapterDependencies as BacklogAdapterDependencies, index$7_ChangelogAdapter as ChangelogAdapter, type index$7_ChangelogAdapterDependencies as ChangelogAdapterDependencies, type index$7_ChangelogListOptions as ChangelogListOptions, type index$7_CollaborationMetrics as CollaborationMetrics, type index$7_DerivedStateSets as DerivedStateSets, type index$7_DerivedStates as DerivedStates, type index$7_EnrichedTaskRecord as EnrichedTaskRecord, type index$7_EnvironmentValidation as EnvironmentValidation, index$7_ExecutionAdapter as ExecutionAdapter, type index$7_ExecutionAdapterDependencies as ExecutionAdapterDependencies, index$7_FeedbackAdapter as FeedbackAdapter, type index$7_FeedbackAdapterDependencies as FeedbackAdapterDependencies, type index$7_FeedbackThread as FeedbackThread, index$7_FileIndexerAdapter as FileIndexerAdapter, type index$7_IBacklogAdapter as IBacklogAdapter, type index$7_IChangelogAdapter as IChangelogAdapter, type index$7_IExecutionAdapter as IExecutionAdapter, type index$7_IFeedbackAdapter as IFeedbackAdapter, type index$7_IIdentityAdapter as IIdentityAdapter, type index$7_IIndexerAdapter as IIndexerAdapter, type index$7_IMetricsAdapter as IMetricsAdapter, type index$7_IProjectAdapter as IProjectAdapter, type index$7_IWorkflowMethodology as IWorkflowMethodology, index$7_IdentityAdapter as IdentityAdapter, type index$7_IdentityAdapterDependencies as IdentityAdapterDependencies, type index$7_IndexData as IndexData, type index$7_IndexGenerationReport as IndexGenerationReport, type index$7_IndexerAdapterDependencies as IndexerAdapterDependencies, type index$7_IntegrityError as IntegrityError, type index$7_IntegrityReport as IntegrityReport, type index$7_IntegrityWarning as IntegrityWarning, index$7_MetricsAdapter as MetricsAdapter, type index$7_MetricsAdapterDependencies as MetricsAdapterDependencies, type index$7_ProductivityMetrics as ProductivityMetrics, index$7_ProjectAdapter as ProjectAdapter, type index$7_ProjectAdapterDependencies as ProjectAdapterDependencies, type index$7_ProjectContext as ProjectContext, type index$7_ProjectInfo as ProjectInfo, type index$7_ProjectInitOptions as ProjectInitOptions, type index$7_ProjectInitResult as ProjectInitResult, type index$7_ProjectReport as ProjectReport, type index$7_SystemStatus as SystemStatus, type index$7_TaskHealthReport as TaskHealthReport, type index$7_TemplateProcessingResult as TemplateProcessingResult, type ValidationContext$1 as ValidationContext, index$7_WorkflowMethodologyAdapter as WorkflowMethodologyAdapter, type index$7_WorkflowMethodologyAdapterDependencies as WorkflowMethodologyAdapterDependencies };
+  export { type index$8_AllRecords as AllRecords, index$8_BacklogAdapter as BacklogAdapter, type index$8_BacklogAdapterConfig as BacklogAdapterConfig, type index$8_BacklogAdapterDependencies as BacklogAdapterDependencies, index$8_ChangelogAdapter as ChangelogAdapter, type index$8_ChangelogAdapterDependencies as ChangelogAdapterDependencies, type index$8_ChangelogListOptions as ChangelogListOptions, type index$8_CollaborationMetrics as CollaborationMetrics, type index$8_DerivedStateSets as DerivedStateSets, type index$8_DerivedStates as DerivedStates, type index$8_EnrichedTaskRecord as EnrichedTaskRecord, type index$8_EnvironmentValidation as EnvironmentValidation, index$8_ExecutionAdapter as ExecutionAdapter, type index$8_ExecutionAdapterDependencies as ExecutionAdapterDependencies, index$8_FeedbackAdapter as FeedbackAdapter, type index$8_FeedbackAdapterDependencies as FeedbackAdapterDependencies, type index$8_FeedbackThread as FeedbackThread, index$8_FileIndexerAdapter as FileIndexerAdapter, type index$8_IBacklogAdapter as IBacklogAdapter, type index$8_IChangelogAdapter as IChangelogAdapter, type index$8_IExecutionAdapter as IExecutionAdapter, type index$8_IFeedbackAdapter as IFeedbackAdapter, type index$8_IIdentityAdapter as IIdentityAdapter, type index$8_IIndexerAdapter as IIndexerAdapter, type index$8_IMetricsAdapter as IMetricsAdapter, type index$8_IProjectAdapter as IProjectAdapter, type index$8_IWorkflowMethodology as IWorkflowMethodology, index$8_IdentityAdapter as IdentityAdapter, type index$8_IdentityAdapterDependencies as IdentityAdapterDependencies, type index$8_IndexData as IndexData, type index$8_IndexGenerationReport as IndexGenerationReport, type index$8_IndexerAdapterDependencies as IndexerAdapterDependencies, type index$8_IntegrityError as IntegrityError, type index$8_IntegrityReport as IntegrityReport, type index$8_IntegrityWarning as IntegrityWarning, index$8_MetricsAdapter as MetricsAdapter, type index$8_MetricsAdapterDependencies as MetricsAdapterDependencies, type index$8_ProductivityMetrics as ProductivityMetrics, index$8_ProjectAdapter as ProjectAdapter, type index$8_ProjectAdapterDependencies as ProjectAdapterDependencies, type index$8_ProjectContext as ProjectContext, type index$8_ProjectInfo as ProjectInfo, type index$8_ProjectInitOptions as ProjectInitOptions, type index$8_ProjectInitResult as ProjectInitResult, type index$8_ProjectReport as ProjectReport, type index$8_SystemStatus as SystemStatus, type index$8_TaskHealthReport as TaskHealthReport, type index$8_TemplateProcessingResult as TemplateProcessingResult, type ValidationContext$1 as ValidationContext, index$8_WorkflowMethodologyAdapter as WorkflowMethodologyAdapter, type index$8_WorkflowMethodologyAdapterDependencies as WorkflowMethodologyAdapterDependencies };
 }
 
 /**
@@ -2871,12 +3679,12 @@ declare function verifySignatures(record: {
     payload: GitGovRecordPayload;
 }, getActorPublicKey: (keyId: string) => Promise<string | null>): Promise<boolean>;
 
-declare const index$6_calculatePayloadChecksum: typeof calculatePayloadChecksum;
-declare const index$6_generateKeys: typeof generateKeys;
-declare const index$6_signPayload: typeof signPayload;
-declare const index$6_verifySignatures: typeof verifySignatures;
-declare namespace index$6 {
-  export { index$6_calculatePayloadChecksum as calculatePayloadChecksum, index$6_generateKeys as generateKeys, index$6_signPayload as signPayload, index$6_verifySignatures as verifySignatures };
+declare const index$7_calculatePayloadChecksum: typeof calculatePayloadChecksum;
+declare const index$7_generateKeys: typeof generateKeys;
+declare const index$7_signPayload: typeof signPayload;
+declare const index$7_verifySignatures: typeof verifySignatures;
+declare namespace index$7 {
+  export { index$7_calculatePayloadChecksum as calculatePayloadChecksum, index$7_generateKeys as generateKeys, index$7_signPayload as signPayload, index$7_verifySignatures as verifySignatures };
 }
 
 /**
@@ -3054,28 +3862,28 @@ declare function createTestSignature(keyId?: string, role?: string, notes?: stri
  */
 declare function createEmbeddedMetadataRecord<T extends GitGovRecordPayload>(payload: T, options?: CreateEmbeddedMetadataOptions): EmbeddedMetadataRecord<T>;
 
-type index$5_CreateEmbeddedMetadataOptions = CreateEmbeddedMetadataOptions;
-type index$5_SignatureConfig = SignatureConfig;
-declare const index$5_createActorRecord: typeof createActorRecord;
-declare const index$5_createAgentRecord: typeof createAgentRecord;
-declare const index$5_createChangelogRecord: typeof createChangelogRecord;
-declare const index$5_createCycleRecord: typeof createCycleRecord;
-declare const index$5_createDefaultWorkflowMethodologyConfig: typeof createDefaultWorkflowMethodologyConfig;
-declare const index$5_createEmbeddedMetadataRecord: typeof createEmbeddedMetadataRecord;
-declare const index$5_createExecutionRecord: typeof createExecutionRecord;
-declare const index$5_createFeedbackRecord: typeof createFeedbackRecord;
-declare const index$5_createTaskRecord: typeof createTaskRecord;
-declare const index$5_createTestSignature: typeof createTestSignature;
-declare const index$5_createWorkflowMethodologyConfig: typeof createWorkflowMethodologyConfig;
-declare const index$5_loadActorRecord: typeof loadActorRecord;
-declare const index$5_loadAgentRecord: typeof loadAgentRecord;
-declare const index$5_loadChangelogRecord: typeof loadChangelogRecord;
-declare const index$5_loadCycleRecord: typeof loadCycleRecord;
-declare const index$5_loadExecutionRecord: typeof loadExecutionRecord;
-declare const index$5_loadFeedbackRecord: typeof loadFeedbackRecord;
-declare const index$5_loadTaskRecord: typeof loadTaskRecord;
-declare namespace index$5 {
-  export { type index$5_CreateEmbeddedMetadataOptions as CreateEmbeddedMetadataOptions, type index$5_SignatureConfig as SignatureConfig, index$5_createActorRecord as createActorRecord, index$5_createAgentRecord as createAgentRecord, index$5_createChangelogRecord as createChangelogRecord, index$5_createCycleRecord as createCycleRecord, index$5_createDefaultWorkflowMethodologyConfig as createDefaultWorkflowMethodologyConfig, index$5_createEmbeddedMetadataRecord as createEmbeddedMetadataRecord, index$5_createExecutionRecord as createExecutionRecord, index$5_createFeedbackRecord as createFeedbackRecord, index$5_createTaskRecord as createTaskRecord, index$5_createTestSignature as createTestSignature, index$5_createWorkflowMethodologyConfig as createWorkflowMethodologyConfig, index$5_loadActorRecord as loadActorRecord, index$5_loadAgentRecord as loadAgentRecord, index$5_loadChangelogRecord as loadChangelogRecord, index$5_loadCycleRecord as loadCycleRecord, index$5_loadExecutionRecord as loadExecutionRecord, index$5_loadFeedbackRecord as loadFeedbackRecord, index$5_loadTaskRecord as loadTaskRecord };
+type index$6_CreateEmbeddedMetadataOptions = CreateEmbeddedMetadataOptions;
+type index$6_SignatureConfig = SignatureConfig;
+declare const index$6_createActorRecord: typeof createActorRecord;
+declare const index$6_createAgentRecord: typeof createAgentRecord;
+declare const index$6_createChangelogRecord: typeof createChangelogRecord;
+declare const index$6_createCycleRecord: typeof createCycleRecord;
+declare const index$6_createDefaultWorkflowMethodologyConfig: typeof createDefaultWorkflowMethodologyConfig;
+declare const index$6_createEmbeddedMetadataRecord: typeof createEmbeddedMetadataRecord;
+declare const index$6_createExecutionRecord: typeof createExecutionRecord;
+declare const index$6_createFeedbackRecord: typeof createFeedbackRecord;
+declare const index$6_createTaskRecord: typeof createTaskRecord;
+declare const index$6_createTestSignature: typeof createTestSignature;
+declare const index$6_createWorkflowMethodologyConfig: typeof createWorkflowMethodologyConfig;
+declare const index$6_loadActorRecord: typeof loadActorRecord;
+declare const index$6_loadAgentRecord: typeof loadAgentRecord;
+declare const index$6_loadChangelogRecord: typeof loadChangelogRecord;
+declare const index$6_loadCycleRecord: typeof loadCycleRecord;
+declare const index$6_loadExecutionRecord: typeof loadExecutionRecord;
+declare const index$6_loadFeedbackRecord: typeof loadFeedbackRecord;
+declare const index$6_loadTaskRecord: typeof loadTaskRecord;
+declare namespace index$6 {
+  export { type index$6_CreateEmbeddedMetadataOptions as CreateEmbeddedMetadataOptions, type index$6_SignatureConfig as SignatureConfig, index$6_createActorRecord as createActorRecord, index$6_createAgentRecord as createAgentRecord, index$6_createChangelogRecord as createChangelogRecord, index$6_createCycleRecord as createCycleRecord, index$6_createDefaultWorkflowMethodologyConfig as createDefaultWorkflowMethodologyConfig, index$6_createEmbeddedMetadataRecord as createEmbeddedMetadataRecord, index$6_createExecutionRecord as createExecutionRecord, index$6_createFeedbackRecord as createFeedbackRecord, index$6_createTaskRecord as createTaskRecord, index$6_createTestSignature as createTestSignature, index$6_createWorkflowMethodologyConfig as createWorkflowMethodologyConfig, index$6_loadActorRecord as loadActorRecord, index$6_loadAgentRecord as loadAgentRecord, index$6_loadChangelogRecord as loadChangelogRecord, index$6_loadCycleRecord as loadCycleRecord, index$6_loadExecutionRecord as loadExecutionRecord, index$6_loadFeedbackRecord as loadFeedbackRecord, index$6_loadTaskRecord as loadTaskRecord };
 }
 
 type StorablePayload = Exclude<GitGovRecordPayload, CustomRecord>;
@@ -3741,22 +4549,22 @@ declare class LintModule implements ILintModule {
  * ```
  */
 
-type index$4_FileSystem = FileSystem;
-type index$4_FixOptions = FixOptions;
-type index$4_FixReport = FixReport;
-type index$4_FixResult = FixResult;
-type index$4_ILintModule = ILintModule;
-type index$4_LintModule = LintModule;
-declare const index$4_LintModule: typeof LintModule;
-type index$4_LintModuleDependencies = LintModuleDependencies;
-type index$4_LintOptions = LintOptions;
-type index$4_LintReport = LintReport;
-type index$4_LintResult = LintResult;
-type index$4_LintSummary = LintSummary;
-type index$4_ValidationContext = ValidationContext;
-type index$4_ValidatorType = ValidatorType;
-declare namespace index$4 {
-  export { type index$4_FileSystem as FileSystem, type index$4_FixOptions as FixOptions, type index$4_FixReport as FixReport, type index$4_FixResult as FixResult, type index$4_ILintModule as ILintModule, index$4_LintModule as LintModule, type index$4_LintModuleDependencies as LintModuleDependencies, type index$4_LintOptions as LintOptions, type index$4_LintReport as LintReport, type index$4_LintResult as LintResult, type index$4_LintSummary as LintSummary, type index$4_ValidationContext as ValidationContext, type index$4_ValidatorType as ValidatorType };
+type index$5_FileSystem = FileSystem;
+type index$5_FixOptions = FixOptions;
+type index$5_FixReport = FixReport;
+type index$5_FixResult = FixResult;
+type index$5_ILintModule = ILintModule;
+type index$5_LintModule = LintModule;
+declare const index$5_LintModule: typeof LintModule;
+type index$5_LintModuleDependencies = LintModuleDependencies;
+type index$5_LintOptions = LintOptions;
+type index$5_LintReport = LintReport;
+type index$5_LintResult = LintResult;
+type index$5_LintSummary = LintSummary;
+type index$5_ValidationContext = ValidationContext;
+type index$5_ValidatorType = ValidatorType;
+declare namespace index$5 {
+  export { type index$5_FileSystem as FileSystem, type index$5_FixOptions as FixOptions, type index$5_FixReport as FixReport, type index$5_FixResult as FixResult, type index$5_ILintModule as ILintModule, index$5_LintModule as LintModule, type index$5_LintModuleDependencies as LintModuleDependencies, type index$5_LintOptions as LintOptions, type index$5_LintReport as LintReport, type index$5_LintResult as LintResult, type index$5_LintSummary as LintSummary, type index$5_ValidationContext as ValidationContext, type index$5_ValidatorType as ValidatorType };
 }
 
 type LogLevel = "debug" | "info" | "warn" | "error" | "silent";
@@ -3769,12 +4577,12 @@ interface Logger {
 declare function createLogger(prefix?: string, level?: LogLevel): Logger;
 declare const logger: Logger;
 
-type index$3_LogLevel = LogLevel;
-type index$3_Logger = Logger;
-declare const index$3_createLogger: typeof createLogger;
-declare const index$3_logger: typeof logger;
-declare namespace index$3 {
-  export { type index$3_LogLevel as LogLevel, type index$3_Logger as Logger, index$3_createLogger as createLogger, index$3_logger as logger };
+type index$4_LogLevel = LogLevel;
+type index$4_Logger = Logger;
+declare const index$4_createLogger: typeof createLogger;
+declare const index$4_logger: typeof logger;
+declare namespace index$4 {
+  export { type index$4_LogLevel as LogLevel, type index$4_Logger as Logger, index$4_createLogger as createLogger, index$4_logger as logger };
 }
 
 /**
@@ -7423,21 +8231,661 @@ declare class DetailedValidationError extends GitGovError {
     }>);
 }
 
-type index$2_DetailedValidationError = DetailedValidationError;
-declare const index$2_DetailedValidationError: typeof DetailedValidationError;
-type index$2_GitGovError = GitGovError;
-declare const index$2_GitGovError: typeof GitGovError;
-type index$2_SchemaName = SchemaName;
-type index$2_SchemaValidationCache = SchemaValidationCache;
-declare const index$2_SchemaValidationCache: typeof SchemaValidationCache;
-type index$2_SchemaValidationError = SchemaValidationError;
-declare const index$2_SchemaValidationError: typeof SchemaValidationError;
-declare const index$2_Schemas: typeof Schemas;
-declare const index$2_getSchema: typeof getSchema;
-declare const index$2_getSchemaNames: typeof getSchemaNames;
-declare const index$2_hasSchema: typeof hasSchema;
+type index$3_DetailedValidationError = DetailedValidationError;
+declare const index$3_DetailedValidationError: typeof DetailedValidationError;
+type index$3_GitGovError = GitGovError;
+declare const index$3_GitGovError: typeof GitGovError;
+type index$3_SchemaName = SchemaName;
+type index$3_SchemaValidationCache = SchemaValidationCache;
+declare const index$3_SchemaValidationCache: typeof SchemaValidationCache;
+type index$3_SchemaValidationError = SchemaValidationError;
+declare const index$3_SchemaValidationError: typeof SchemaValidationError;
+declare const index$3_Schemas: typeof Schemas;
+declare const index$3_getSchema: typeof getSchema;
+declare const index$3_getSchemaNames: typeof getSchemaNames;
+declare const index$3_hasSchema: typeof hasSchema;
+declare namespace index$3 {
+  export { index$3_DetailedValidationError as DetailedValidationError, index$3_GitGovError as GitGovError, type index$3_SchemaName as SchemaName, index$3_SchemaValidationCache as SchemaValidationCache, index$3_SchemaValidationError as SchemaValidationError, index$3_Schemas as Schemas, index$3_getSchema as getSchema, index$3_getSchemaNames as getSchemaNames, index$3_hasSchema as hasSchema };
+}
+
+/**
+ * SyncModule Dependencies
+ */
+interface SyncModuleDependencies {
+    /** Low-level Git module (required) */
+    git: GitModule;
+    /** Configuration manager (required) */
+    config: ConfigManager;
+    /** Identity adapter for signature verification and signing (required) */
+    identity: IIdentityAdapter;
+    /** Lint module for record validation (required) */
+    lint: LintModule;
+    /** Indexer adapter for automatic re-indexing after pull/resolve (required) */
+    indexer: IIndexerAdapter;
+}
+/**
+ * Options for pushState operation
+ */
+interface SyncPushOptions {
+    /** Branch to push from (default: current branch) */
+    sourceBranch?: string;
+    /** Actor ID publishing the state (required) */
+    actorId: string;
+    /** Simulate operation without making real changes */
+    dryRun?: boolean;
+    /** Force push even if there are unsynced remote changes */
+    force?: boolean;
+}
+/**
+ * Result of pushState operation
+ */
+interface SyncPushResult {
+    /** Indicates if the operation was successful */
+    success: boolean;
+    /** Number of files synced */
+    filesSynced: number;
+    /** Name of the branch pushed from */
+    sourceBranch: string;
+    /** Created commit hash (null if no changes or dry-run) */
+    commitHash: string | null;
+    /** Created commit message */
+    commitMessage: string | null;
+    /** Indicates if a conflict was detected during reconciliation */
+    conflictDetected: boolean;
+    /** Conflict information if detected */
+    conflictInfo?: ConflictInfo;
+    /** Error message if operation failed */
+    error?: string;
+}
+/**
+ * Options for pullState operation
+ */
+interface SyncPullOptions {
+    /** Force re-indexing even if there are no new changes */
+    forceReindex?: boolean;
+}
+/**
+ * Result of pullState operation
+ */
+interface SyncPullResult {
+    /** Indicates if the operation was successful */
+    success: boolean;
+    /** Indicates if there were new remote changes */
+    hasChanges: boolean;
+    /** Number of files updated */
+    filesUpdated: number;
+    /** Indicates if re-indexing was executed */
+    reindexed: boolean;
+    /** Indicates if a conflict was detected during pull */
+    conflictDetected: boolean;
+    /** Conflict information if detected */
+    conflictInfo?: ConflictInfo;
+    /** Error message if operation failed */
+    error?: string;
+}
+/**
+ * Options for resolveConflict operation
+ */
+interface SyncResolveOptions {
+    /** Justification for the conflict resolution (required) */
+    reason: string;
+    /** Actor ID resolving the conflict (required) */
+    actorId: string;
+}
+/**
+ * Result of resolveConflict operation
+ */
+interface SyncResolveResult {
+    /** Indicates if the operation was successful */
+    success: boolean;
+    /** Commit hash of the created rebase commit */
+    rebaseCommitHash: string;
+    /** Commit hash of the signed resolution commit */
+    resolutionCommitHash: string;
+    /** Number of conflicts resolved */
+    conflictsResolved: number;
+    /** Actor ID who resolved the conflict */
+    resolvedBy: string;
+    /** Reason for resolution */
+    reason: string;
+    /** Error message if operation failed */
+    error?: string;
+}
+/**
+ * Detailed information about a detected conflict
+ */
+interface ConflictInfo {
+    /** Type of conflict detected */
+    type: ConflictType;
+    /** Files affected by the conflict */
+    affectedFiles: string[];
+    /** Descriptive message of the conflict */
+    message: string;
+    /** Instructions to resolve the conflict */
+    resolutionSteps: string[];
+}
+/**
+ * Auxiliary type to identify the conflict type
+ */
+type ConflictType = "rebase_conflict" | "merge_conflict" | "integrity_violation" | "unresolved_markers";
+/**
+ * Information about a detected integrity violation
+ */
+interface IntegrityViolation {
+    /** Commit hash of the rebase commit without resolution */
+    rebaseCommitHash: string;
+    /** Message of the rebase commit */
+    commitMessage: string;
+    /** Timestamp of the commit */
+    timestamp: string;
+    /** Author of the commit */
+    author: string;
+}
+/**
+ * Verification scope for state audit
+ */
+type AuditScope = "current" | "state-branch" | "all";
+/**
+ * Scope for expected files verification
+ */
+type ExpectedFilesScope = "head" | "all-commits";
+/**
+ * Options for state audit
+ */
+interface AuditStateOptions {
+    /** Verification scope: which Records to verify (default: "all") */
+    scope?: AuditScope;
+    /** Verify signatures in Records (default: true) */
+    verifySignatures?: boolean;
+    /** Verify checksums of Records (default: true) */
+    verifyChecksums?: boolean;
+    /** Verify that expected files exist (default: true) */
+    verifyExpectedFiles?: boolean;
+    /** Scope for expected files verification (default: "head") */
+    expectedFilesScope?: ExpectedFilesScope;
+    /** Path of specific files to audit (default: all in .gitgov/) */
+    filePaths?: string[];
+}
+/**
+ * Conflict diff information for a file
+ */
+interface ConflictFileDiff {
+    /** Path of the conflicted file */
+    filePath: string;
+    /** Content of the local version (ours) */
+    localContent: string;
+    /** Content of the remote version (theirs) */
+    remoteContent: string;
+    /** Base content (common ancestor) */
+    baseContent: string | null;
+    /** Lines with conflict markers (if they still exist) */
+    conflictMarkers?: Array<{
+        line: number;
+        marker: string;
+    }>;
+}
+/**
+ * Structured conflict diff
+ */
+interface ConflictDiff {
+    /** Conflicted files with their diff */
+    files: ConflictFileDiff[];
+    /** Descriptive message of the conflict */
+    message: string;
+    /** Instructions to resolve */
+    resolutionSteps: string[];
+}
+/**
+ * Complete state audit report
+ *
+ * This report combines SyncModule-specific audits (rebase integrity, commits)
+ * with structural validation from LintModule (signatures, checksums, schemas).
+ */
+interface AuditStateReport {
+    /** Indicates if the audit passed without violations */
+    passed: boolean;
+    /** Scope used for the audit */
+    scope: AuditScope;
+    /** Total commits analyzed */
+    totalCommits: number;
+    /** Rebase commits found */
+    rebaseCommits: number;
+    /** Resolution commits found */
+    resolutionCommits: number;
+    /** Integrity violations of resolutions (SyncModule-specific) */
+    integrityViolations: IntegrityViolation[];
+    /** Summary message of the audit */
+    summary: string;
+    /** Complete LintModule report for structural validation (signatures, checksums, schemas, etc.) */
+    lintReport?: LintReport;
+}
+/**
+ * Information of a changed file in the delta
+ */
+interface StateDeltaFile {
+    /** File status: Added, Modified, Deleted */
+    status: "A" | "M" | "D";
+    /** File path */
+    file: string;
+}
+
+/**
+ * SyncModule - Manages state synchronization between local environment and gitgov-state branch
+ *
+ * Responsibilities:
+ * - Create and maintain the gitgov-state branch (local and remote)
+ * - Publish local changes (pushState)
+ * - Pull remote changes (pullState)
+ * - Resolve conflicts in a governed manner (resolveConflict)
+ * - Audit state integrity (auditState)
+ *
+ * Philosophy:
+ * - Pipeline Pattern: Sequential operations with validation at each phase
+ * - Fail-Fast: Early verifications to avoid costly operations
+ * - Strict Dependencies: All dependencies (git, config, identity, lint, indexer) are required for robust operations
+ */
+declare class SyncModule {
+    private git;
+    private config;
+    private identity;
+    private lint;
+    private indexer;
+    /**
+     * Constructor with dependency injection
+     */
+    constructor(dependencies: SyncModuleDependencies);
+    /**
+     * Static method to bootstrap .gitgov/ from gitgov-state branch.
+     * Used when cloning a repo that has gitgov-state but .gitgov/ is not in the work branch.
+     *
+     * This method only requires GitModule and can be called before full SyncModule initialization.
+     *
+     * @param gitModule - GitModule instance for git operations
+     * @param stateBranch - Name of the state branch (default: "gitgov-state")
+     * @returns Promise<{ success: boolean; error?: string }>
+     */
+    static bootstrapFromStateBranch(gitModule: GitModule, stateBranch?: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Gets the state branch name from configuration.
+     * Default: "gitgov-state"
+     *
+     * [EARS-4]
+     */
+    getStateBranchName(): Promise<string>;
+    /**
+     * Ensures that the gitgov-state branch exists both locally and remotely.
+     * If it doesn't exist, creates it as an orphan branch.
+     *
+     * Use cases (4 edge cases):
+     * 1. Doesn't exist locally or remotely → Create orphan branch + initial commit + push
+     * 2. Exists remotely, not locally → Fetch + create local + set tracking
+     * 3. Exists locally, not remotely → Push + set tracking
+     * 4. Exists both → Verify tracking
+     *
+     * [EARS-1, EARS-2, EARS-3]
+     */
+    ensureStateBranch(): Promise<void>;
+    /**
+     * Creates the gitgov-state orphan branch with an empty initial commit.
+     * Used by ensureStateBranch when the branch doesn't exist locally or remotely.
+     *
+     * [EARS-1]
+     */
+    private createOrphanStateBranch;
+    /**
+     * Calculates the file delta in .gitgov/ between the current branch and gitgov-state.
+     *
+     * [EARS-5]
+     */
+    calculateStateDelta(sourceBranch: string): Promise<StateDeltaFile[]>;
+    /**
+     * Checks if a rebase is in progress.
+     *
+     * [EARS-22]
+     */
+    isRebaseInProgress(): Promise<boolean>;
+    /**
+     * Checks for absence of conflict markers in specified files.
+     * Returns list of files that still have markers.
+     *
+     * [EARS-23]
+     */
+    checkConflictMarkers(filePaths: string[]): Promise<string[]>;
+    /**
+     * Gets the diff of conflicted files for manual analysis.
+     * Useful so the actor can analyze conflicted changes before resolving.
+     *
+     * [EARS-31]
+     */
+    getConflictDiff(filePaths?: string[]): Promise<ConflictDiff>;
+    /**
+     * Verifies integrity of previous resolutions in gitgov-state history.
+     * Returns list of violations if any exist.
+     *
+     * [EARS-24, EARS-25, EARS-26]
+     */
+    verifyResolutionIntegrity(): Promise<IntegrityViolation[]>;
+    /**
+     * Complete audit of gitgov-state status.
+     * Verifies integrity of resolutions, signatures in Records, checksums and expected files.
+     *
+     * [EARS-27, EARS-28, EARS-29, EARS-30]
+     */
+    auditState(options?: AuditStateOptions): Promise<AuditStateReport>;
+    /**
+     * Publishes local state changes to gitgov-state.
+     * Implements 3 phases: verification, reconciliation, publication.
+     *
+     * [EARS-6 through EARS-12]
+     */
+    pushState(options: SyncPushOptions): Promise<SyncPushResult>;
+    /**
+     * Pulls remote changes from gitgov-state to the local environment.
+     * Includes automatic re-indexing if there are new changes.
+     *
+     * [EARS-13 through EARS-16]
+     * [EARS-44] Requires remote to be configured (pull without remote makes no sense)
+     */
+    pullState(options?: SyncPullOptions): Promise<SyncPullResult>;
+    /**
+     * Resolves state conflicts in a governed manner.
+     * Updates resolved Records (recalculates checksum and adds resolver signature),
+     * creates rebase and resolution commits signed according to protocol.
+     *
+     * [EARS-17 through EARS-23]
+     */
+    resolveConflict(options: SyncResolveOptions): Promise<SyncResolveResult>;
+}
+
+/**
+ * PullScheduler - Periodic State Synchronization
+ *
+ * Background scheduler that automatically pulls state changes from remote
+ * at configured intervals.
+ *
+ * @module sync/pull_scheduler
+ */
+
+/**
+ * Result of a pull operation executed by the scheduler
+ */
+interface PullSchedulerResult {
+    /** Whether the operation was successful */
+    success: boolean;
+    /** Whether new changes were detected */
+    hasChanges: boolean;
+    /** Whether a conflict was detected */
+    conflictDetected: boolean;
+    /** Conflict information if applicable */
+    conflictInfo?: {
+        type: string;
+        message: string;
+        affectedFiles?: string[];
+    };
+    /** Timestamp of the operation */
+    timestamp: string;
+    /** Error if operation failed */
+    error?: string;
+}
+/**
+ * Configuration for the PullScheduler
+ */
+interface PullSchedulerConfig {
+    /** Whether the scheduler is enabled */
+    enabled: boolean;
+    /** Pull interval in seconds */
+    pullIntervalSeconds: number;
+    /** Whether to continue after network errors */
+    continueOnNetworkError: boolean;
+    /** Whether to stop if a conflict is detected */
+    stopOnConflict: boolean;
+}
+/**
+ * Dependencies required by PullScheduler
+ */
+interface PullSchedulerDependencies {
+    /** SyncModule for pull operations */
+    syncModule: SyncModule;
+    /** ConfigManager for loading configuration */
+    configManager: ConfigManager;
+}
+/**
+ * PullScheduler - Automatic background synchronization
+ *
+ * Periodically pulls state changes from remote to keep local state up-to-date.
+ * Useful for collaboration scenarios where multiple actors are working simultaneously.
+ *
+ * [EARS-33 to EARS-40]
+ *
+ * @example
+ * ```typescript
+ * const scheduler = new PullScheduler({
+ *   syncModule,
+ *   configManager
+ * });
+ *
+ * await scheduler.start(); // Start periodic pulling
+ * // ... scheduler runs in background ...
+ * scheduler.stop(); // Stop scheduler
+ * ```
+ */
+declare class PullScheduler {
+    private syncModule;
+    private configManager;
+    private config;
+    private intervalId?;
+    private running;
+    private pulling;
+    constructor(dependencies: PullSchedulerDependencies);
+    /**
+     * Loads configuration from ConfigManager with cascade merge:
+     * 1. Local preferences in .session.json (highest priority)
+     * 2. Project defaults in config.json
+     * 3. Hardcoded defaults (fallback)
+     */
+    private loadConfig;
+    /**
+     * Starts the scheduler with configured interval
+     *
+     * [EARS-33, EARS-34]
+     *
+     * @throws Error if scheduler fails to load configuration
+     *
+     * @example
+     * ```typescript
+     * await scheduler.start();
+     * // Scheduler now pulls every N seconds
+     * ```
+     */
+    start(): Promise<void>;
+    /**
+     * Stops the scheduler and cleans up resources
+     *
+     * [EARS-35]
+     *
+     * @example
+     * ```typescript
+     * scheduler.stop();
+     * // Scheduler is now stopped
+     * ```
+     */
+    stop(): void;
+    /**
+     * Checks if the scheduler is currently running
+     *
+     * [EARS-36]
+     *
+     * @returns true if running, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (scheduler.isRunning()) {
+     *   console.log("Scheduler is active");
+     * }
+     * ```
+     */
+    isRunning(): boolean;
+    /**
+     * Executes a pull operation immediately
+     *
+     * This method can be called manually or is automatically invoked by the scheduler.
+     * Handles conflicts, network errors, and concurrent pull prevention.
+     *
+     * [EARS-37, EARS-38, EARS-39, EARS-40]
+     *
+     * @returns Result of the pull operation
+     *
+     * @example
+     * ```typescript
+     * const result = await scheduler.pullNow();
+     * if (result.hasChanges) {
+     *   console.log("New changes detected");
+     * }
+     * ```
+     */
+    pullNow(): Promise<PullSchedulerResult>;
+}
+
+/**
+ * Base error class for all sync-related errors
+ */
+declare class SyncError extends Error {
+    constructor(message: string);
+}
+/**
+ * Error thrown when attempting to push from gitgov-state branch
+ */
+declare class PushFromStateBranchError extends SyncError {
+    branch: string;
+    constructor(branchName: string);
+}
+/**
+ * Error thrown when integrity violations are detected during audit
+ */
+declare class IntegrityViolationError extends SyncError {
+    violations: Array<{
+        type: "resolution" | "signature" | "checksum" | "missing_file";
+        details: string;
+    }>;
+    constructor(violations: Array<{
+        type: "resolution" | "signature" | "checksum" | "missing_file";
+        details: string;
+    }>);
+}
+/**
+ * Error thrown when conflict markers are still present in files
+ */
+declare class ConflictMarkersPresentError extends SyncError {
+    filesWithMarkers: string[];
+    constructor(filesWithMarkers: string[]);
+}
+/**
+ * Error thrown when attempting to resolve conflict without rebase in progress
+ */
+declare class NoRebaseInProgressError extends SyncError {
+    constructor();
+}
+/**
+ * Error thrown when CryptoModule is required but not available
+ */
+declare class CryptoModuleRequiredError extends SyncError {
+    constructor(operation: string);
+}
+/**
+ * Error thrown when state branch cannot be created or configured
+ */
+declare class StateBranchSetupError extends SyncError {
+    reason: string;
+    underlyingError?: Error | undefined;
+    constructor(reason: string, underlyingError?: Error | undefined);
+}
+/**
+ * Error thrown when uncommitted changes exist in state branch
+ */
+declare class UncommittedChangesError extends SyncError {
+    branch: string;
+    constructor(branchName: string);
+}
+/**
+ * Type guards for error handling
+ *
+ * These functions enable type-safe error handling by narrowing the error type.
+ * They are additive and don't break any existing code.
+ *
+ * Example usage:
+ * ```typescript
+ * try {
+ *   await syncModule.pushState(options);
+ * } catch (error) {
+ *   if (isPushFromStateBranchError(error)) {
+ *     // TypeScript knows error.branch exists here
+ *     console.log(`Cannot push from ${error.branch}`);
+ *   }
+ * }
+ * ```
+ */
+declare function isSyncError(error: unknown): error is SyncError;
+declare function isPushFromStateBranchError(error: unknown): error is PushFromStateBranchError;
+declare function isIntegrityViolationError(error: unknown): error is IntegrityViolationError;
+declare function isConflictMarkersPresentError(error: unknown): error is ConflictMarkersPresentError;
+declare function isUncommittedChangesError(error: unknown): error is UncommittedChangesError;
+declare function isNoRebaseInProgressError(error: unknown): error is NoRebaseInProgressError;
+declare function isStateBranchSetupError(error: unknown): error is StateBranchSetupError;
+declare function isCryptoModuleRequiredError(error: unknown): error is CryptoModuleRequiredError;
+
+type index$2_AuditScope = AuditScope;
+type index$2_AuditStateOptions = AuditStateOptions;
+type index$2_AuditStateReport = AuditStateReport;
+type index$2_ConflictDiff = ConflictDiff;
+type index$2_ConflictFileDiff = ConflictFileDiff;
+type index$2_ConflictInfo = ConflictInfo;
+type index$2_ConflictMarkersPresentError = ConflictMarkersPresentError;
+declare const index$2_ConflictMarkersPresentError: typeof ConflictMarkersPresentError;
+type index$2_ConflictType = ConflictType;
+type index$2_CryptoModuleRequiredError = CryptoModuleRequiredError;
+declare const index$2_CryptoModuleRequiredError: typeof CryptoModuleRequiredError;
+type index$2_ExpectedFilesScope = ExpectedFilesScope;
+type index$2_IntegrityViolation = IntegrityViolation;
+type index$2_IntegrityViolationError = IntegrityViolationError;
+declare const index$2_IntegrityViolationError: typeof IntegrityViolationError;
+type index$2_NoRebaseInProgressError = NoRebaseInProgressError;
+declare const index$2_NoRebaseInProgressError: typeof NoRebaseInProgressError;
+type index$2_PullScheduler = PullScheduler;
+declare const index$2_PullScheduler: typeof PullScheduler;
+type index$2_PullSchedulerConfig = PullSchedulerConfig;
+type index$2_PullSchedulerDependencies = PullSchedulerDependencies;
+type index$2_PullSchedulerResult = PullSchedulerResult;
+type index$2_PushFromStateBranchError = PushFromStateBranchError;
+declare const index$2_PushFromStateBranchError: typeof PushFromStateBranchError;
+type index$2_StateBranchSetupError = StateBranchSetupError;
+declare const index$2_StateBranchSetupError: typeof StateBranchSetupError;
+type index$2_StateDeltaFile = StateDeltaFile;
+type index$2_SyncError = SyncError;
+declare const index$2_SyncError: typeof SyncError;
+type index$2_SyncModule = SyncModule;
+declare const index$2_SyncModule: typeof SyncModule;
+type index$2_SyncModuleDependencies = SyncModuleDependencies;
+type index$2_SyncPullOptions = SyncPullOptions;
+type index$2_SyncPullResult = SyncPullResult;
+type index$2_SyncPushOptions = SyncPushOptions;
+type index$2_SyncPushResult = SyncPushResult;
+type index$2_SyncResolveOptions = SyncResolveOptions;
+type index$2_SyncResolveResult = SyncResolveResult;
+type index$2_UncommittedChangesError = UncommittedChangesError;
+declare const index$2_UncommittedChangesError: typeof UncommittedChangesError;
+declare const index$2_isConflictMarkersPresentError: typeof isConflictMarkersPresentError;
+declare const index$2_isCryptoModuleRequiredError: typeof isCryptoModuleRequiredError;
+declare const index$2_isIntegrityViolationError: typeof isIntegrityViolationError;
+declare const index$2_isNoRebaseInProgressError: typeof isNoRebaseInProgressError;
+declare const index$2_isPushFromStateBranchError: typeof isPushFromStateBranchError;
+declare const index$2_isStateBranchSetupError: typeof isStateBranchSetupError;
+declare const index$2_isSyncError: typeof isSyncError;
+declare const index$2_isUncommittedChangesError: typeof isUncommittedChangesError;
 declare namespace index$2 {
-  export { index$2_DetailedValidationError as DetailedValidationError, index$2_GitGovError as GitGovError, type index$2_SchemaName as SchemaName, index$2_SchemaValidationCache as SchemaValidationCache, index$2_SchemaValidationError as SchemaValidationError, index$2_Schemas as Schemas, index$2_getSchema as getSchema, index$2_getSchemaNames as getSchemaNames, index$2_hasSchema as hasSchema };
+  export { type index$2_AuditScope as AuditScope, type index$2_AuditStateOptions as AuditStateOptions, type index$2_AuditStateReport as AuditStateReport, type index$2_ConflictDiff as ConflictDiff, type index$2_ConflictFileDiff as ConflictFileDiff, type index$2_ConflictInfo as ConflictInfo, index$2_ConflictMarkersPresentError as ConflictMarkersPresentError, type index$2_ConflictType as ConflictType, index$2_CryptoModuleRequiredError as CryptoModuleRequiredError, type index$2_ExpectedFilesScope as ExpectedFilesScope, type index$2_IntegrityViolation as IntegrityViolation, index$2_IntegrityViolationError as IntegrityViolationError, index$2_NoRebaseInProgressError as NoRebaseInProgressError, index$2_PullScheduler as PullScheduler, type index$2_PullSchedulerConfig as PullSchedulerConfig, type index$2_PullSchedulerDependencies as PullSchedulerDependencies, type index$2_PullSchedulerResult as PullSchedulerResult, index$2_PushFromStateBranchError as PushFromStateBranchError, index$2_StateBranchSetupError as StateBranchSetupError, type index$2_StateDeltaFile as StateDeltaFile, index$2_SyncError as SyncError, index$2_SyncModule as SyncModule, type index$2_SyncModuleDependencies as SyncModuleDependencies, type index$2_SyncPullOptions as SyncPullOptions, type index$2_SyncPullResult as SyncPullResult, type index$2_SyncPushOptions as SyncPushOptions, type index$2_SyncPushResult as SyncPushResult, type index$2_SyncResolveOptions as SyncResolveOptions, type index$2_SyncResolveResult as SyncResolveResult, index$2_UncommittedChangesError as UncommittedChangesError, index$2_isConflictMarkersPresentError as isConflictMarkersPresentError, index$2_isCryptoModuleRequiredError as isCryptoModuleRequiredError, index$2_isIntegrityViolationError as isIntegrityViolationError, index$2_isNoRebaseInProgressError as isNoRebaseInProgressError, index$2_isPushFromStateBranchError as isPushFromStateBranchError, index$2_isStateBranchSetupError as isStateBranchSetupError, index$2_isSyncError as isSyncError, index$2_isUncommittedChangesError as isUncommittedChangesError };
 }
 
 /**
@@ -7977,4 +9425,4 @@ declare namespace index {
   export { index_CircularDependencyError as CircularDependencyError, index_ContentSanitizer as ContentSanitizer, type index_DiagramEdge as DiagramEdge, index_DiagramGenerator as DiagramGenerator, index_DiagramMetrics as DiagramMetrics, type index_DiagramNode as DiagramNode, type index_DiagramOptions as DiagramOptions, index_MermaidRenderer as MermaidRenderer, index_MermaidValidator as MermaidValidator, index_RelationshipAnalyzer as RelationshipAnalyzer, type index_RelationshipGraph as RelationshipGraph, index_RenderingError as RenderingError };
 }
 
-export { index$7 as Adapters, index$b as BacklogAdapter, index$e as ChangelogAdapter, index$9 as Config, index$6 as Crypto, index as DiagramGenerator, index$i as EventBus, index$f as ExecutionAdapter, index$5 as Factories, index$g as FeedbackAdapter, index$h as IdentityAdapter, index$a as IndexerAdapter, index$4 as Lint, index$3 as Logger, index$d as MetricsAdapter, index$8 as ProjectAdapter, index$k as Records, index$2 as Schemas, index$j as Store, index$1 as Validation, index$c as WorkflowMethodologyAdapter };
+export { index$8 as Adapters, index$c as BacklogAdapter, index$g as ChangelogAdapter, index$e as Config, index$7 as Crypto, index as DiagramGenerator, index$k as EventBus, index$h as ExecutionAdapter, index$6 as Factories, index$i as FeedbackAdapter, index$a as Git, index$j as IdentityAdapter, index$b as IndexerAdapter, index$5 as Lint, index$4 as Logger, index$f as MetricsAdapter, index$9 as ProjectAdapter, index$m as Records, index$3 as Schemas, index$l as Store, index$2 as Sync, index$1 as Validation, index$d as WorkflowMethodologyAdapter };